diff --git a/src/route/routing-table-calculator.hpp b/src/route/routing-table-calculator.hpp
index 4ee683e..bfeeb87 100644
--- a/src/route/routing-table-calculator.hpp
+++ b/src/route/routing-table-calculator.hpp
@@ -46,30 +46,56 @@
     m_nRouters = nRouters;
   }
 protected:
+  /*! \brief Allocate the space needed for the adj. matrix. */
   void
   allocateAdjMatrix();
 
+  /*! \brief Zero every cell of the matrix to ensure that the memory is safe. */
   void
   initMatrix();
 
+  /*! \brief Constructs an adj. matrix to calculate with.
+    \param pnlsr The NLSR object that contains the LSAs that we need to iterate
+    over.
+    \param pMap The map to populate with the adj. data.
+  */
   void
   makeAdjMatrix(Nlsr& pnlsr, Map pMap);
 
   void
   writeAdjMatrixLog();
 
+  /*! \brief Returns how many links a router in the matrix has.
+    \param sRouter The router to count the links of.
+  */
   int
   getNumOfLinkfromAdjMatrix(int sRouter);
 
   void
   freeAdjMatrix();
-
+  /*! \brief Adjust a link cost in the adj. matrix
+    \param source The source router whose adjacency to adjust.
+    \param link The adjacency of the source to adjust.
+    \param linkCost The cost to change to.
+  */
   void
   adjustAdMatrix(int source, int link, double linkCost);
 
+  /*! \brief Populates temp. variables with the link costs for some router.
+    \param source The router whose values are to be adjusted.
+    \param links An integer pointer array for the link mappingNos.
+    \param linkCosts A double pointer array that stores the link costs.
+
+    Obtains a sparse list of adjacencies and link costs for some
+    router. Since this is sparse, that means while generating these
+    arrays, if there is no adjacency at i in the matrix, these
+    temporary variables will not contain a 0 at i, but rather will
+    contain the values for the next valid adjacency.
+  */
   void
   getLinksFromAdjMatrix(int* links, double* linkCosts, int source);
 
+  /*! Allocates an array large enough to hold multipath calculation temps. */
   void
   allocateLinks();
 
@@ -113,12 +139,30 @@
   calculatePath(Map& pMap, RoutingTable& rt, Nlsr& pnlsr);
 
 private:
+  /*! \brief Performs a Dijkstra's calculation over the adjacency matrix.
+    \param sourceRouter The origin router to compute paths from.
+  */
   void
   doDijkstraPathCalculation(int sourceRouter);
 
+  /*! \brief Sort the elements of a list.
+    \param Q The array that contains the elements to sort.
+    \param dist The array that contains the distances.
+    \param start The first element in the list to sort.
+    \param element The last element in the list to sort through.
+
+    Sorts the list based on distance. The distances are indexed by
+    their mappingNo in dist. Currently uses an insertion sort.
+  */
   void
   sortQueueByDistance(int* Q, double* dist, int start, int element);
 
+  /*! \brief Returns whether an element has been visited yet.
+    \param Q The list of elements to look through.
+    \param u The element to check.
+    \param start The start of list to look through.
+    \param element The end of the list to look through.
+  */
   int
   isNotExplored(int* Q, int u, int start, int element);
 
@@ -126,6 +170,10 @@
   addAllLsNextHopsToRoutingTable(Nlsr& pnlsr, RoutingTable& rt,
                                  Map& pMap, uint32_t sourceRouter);
 
+  /*! \brief Determines a destination's next hop.
+    \param dest The router whose next hop we want to determine.
+    \param source The router to determine a next path to.
+  */
   int
   getLsNextHop(int dest, int source);