improved loss function, added dictionaries for fast searching

Author: davidcheungo123

Diff for: algo_improved.c

@@ -1,4 +1,3 @@
-
 from libc.math cimport sin , cos, sqrt, fabs
 import numpy as np
 cimport numpy as cnp
@@ -14,30 +13,32 @@ cdef:
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def findDepth(dict specificNode , list parsedLinkData):
-    cdef int temp = 0
+def findDepth(dict specificNode , list parsedLinkData, dict nodeIDMapToParsedLinkDataIndexTarget):
+    cdef int temp = 1
     cdef float length = 0
     cdef list linkWithTarget
     cdef dict currentNode = specificNode
     while True:
         ## this can be imporved using hashmap
-        linkWithTarget = [x for x in parsedLinkData if x['target']['id'] == currentNode["id"]]
+        ## linkWithTarget = [x for x in parsedLinkData if x['target']['id'] == currentNode["id"]]
+        linkWithTarget = [parsedLinkData[nodeIDMapToParsedLinkDataIndexTarget[currentNode["id"]]]] if nodeIDMapToParsedLinkDataIndexTarget.get(currentNode["id"], None) is not None else []
         if len(linkWithTarget)==0:
             return (temp, length)
         else:
-            temp = temp +1
+            temp += 1
             length = length + linkWithTarget[0]['len']
             currentNode = linkWithTarget[0]['source']
 
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def findRootNode(dict randomNode, list parsedLinkData):
+def findRootNode(dict randomNode, list parsedLinkData,  dict nodeIDMapToParsedLinkDataIndexTarget):
     cdef dict currentNode = randomNode
     cdef list linkWithTarget
     while True:
         ## this can be imporved using hashmap
-        linkWithTarget = [x for x in parsedLinkData if x['target']['id'] == currentNode["id"]]
+        ## linkWithTarget = [x for x in parsedLinkData if x['target']['id'] == currentNode["id"]]
+        linkWithTarget = [parsedLinkData[nodeIDMapToParsedLinkDataIndexTarget[currentNode["id"]]]] if nodeIDMapToParsedLinkDataIndexTarget.get(currentNode["id"], None) is not None else []
         if len(linkWithTarget)==0:
             return currentNode
         else:
@@ -46,12 +47,13 @@ def findRootNode(dict randomNode, list parsedLinkData):
 ## find the nodes from "endNode" to node "startNode" without the startNode itself
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def reversebfs(dict startNode, list parsedLinkData):
+def reversebfs(dict startNode, list parsedLinkData,  dict nodeIDMapToParsedLinkDataIndexTarget):
     cdef list path = []
     cdef dict currentNode = startNode , currentLink
     while True:
         ## this can be imporved using hashmap
-        linkWithTarget = [x for x in parsedLinkData if x['target']['id'] == currentNode["id"]]
+        ## linkWithTarget = [x for x in parsedLinkData if x['target']['id'] == currentNode["id"]]
+        linkWithTarget = [parsedLinkData[nodeIDMapToParsedLinkDataIndexTarget[currentNode["id"]]]] if nodeIDMapToParsedLinkDataIndexTarget.get(currentNode["id"], None) is not None else []
         if len(linkWithTarget)==0:
             break
         else:
@@ -74,6 +76,7 @@ def updateCoordinatesX(double[:] x , double[:] y, float cX ,float cY, float rad,
     return new_x
 
 
+
 @cython.boundscheck(False)
 @cython.wraparound(False)
 def updateCoordinatesY(double[:] x, double[:] y, float cX, float cY, float rad, int l):
@@ -126,6 +129,10 @@ def lossFunction(dict node,float realTheta,list parsedLinkData, dict nodeIDMapTo
             deltaY =  matchedLinkObject['target']['y'] - matchedLinkObject['source']['y']
             return ((middleX - cX)* (deltaX) + (middleY - cY)* (deltaY)) /  sqrt(a*b)
 
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def lossFunctionWithDepth(dict node,float realTheta, int depth, list parsedLinkData, dict nodeIDMapToParsedLinkDataIndexTarget):
+    pass
 
 ## can be destructured to function(hashTable, requiredNode)
 @cython.boundscheck(False)
@@ -225,7 +232,6 @@ cdef bint checkInfiniteCollision(float sourceX, float sourceY, float targetX, fl
         dist = fabs(m*centreX - centreY + c) / sqrt(m*m +1)
         return (dist <= R)
 
-
 @cython.boundscheck(False)
 @cython.wraparound(False)
 def calIntersectionNum(list links, list requiredLinkIDs, list filteredLinksIDs ):
@@ -288,15 +294,17 @@ def findIntersection(list links):
 
 ## all nodes inputed should not be root node here
 @cython.boundscheck(False)
+@cython.wraparound(False)
 def mainAlgo(dict node, dict link, list parsedNodeData, list parsedLinkData, float THETA, float LAMBDA,
     dict nodeIDMapToParsedLinkDataIndexSource, dict nodeIDMapToParsedLinkDataIndexTarget, dict nodeIDMapToParsedNodeDataIndex,
-    dict linkIDMapToParsedNodeDataIndexSource, dict linkIDMapToParsedNodeDataIndexTarget, dict linkIDMapToParsedLinkDataIndex
+    dict linkIDMapToParsedNodeDataIndexSource, dict linkIDMapToParsedNodeDataIndexTarget, dict linkIDMapToParsedLinkDataIndex,
+    dict depth
     ):
 
     cdef:
         int numOfIntersections, iterations = 0, currentNodeIndex, nodeIndex, breakFromWhile = 0, tempIndex = 1
         list requiredUpdateNode = search(node['id'], nodeIDMapToParsedLinkDataIndexSource,  nodeIDMapToParsedLinkDataIndexTarget, parsedLinkData)
-        int l = len(requiredUpdateNode), N = len(parsedLinkData), recordLength
+        int l = len(requiredUpdateNode), N = len(parsedLinkData), recordLength = 0, nodeDepth = depth[node["id"]]
         unsigned int indexing, index
         long[:] orderedNodeIndex = np.zeros(l, dtype=long)
         ## a numpy float is a C double.
@@ -312,10 +320,12 @@ def mainAlgo(dict node, dict link, list parsedNodeData, list parsedLinkData, flo
     for index in range(l):
         linkObjects[index] = nodeIDMapToParsedLinkDataIndexTarget[requiredUpdateNode[index]]
         orderedNodeIndex[index] = nodeIDMapToParsedNodeDataIndex[requiredUpdateNode[index]]
-        orderedNodeX[index] = float(parsedNodeData[orderedNodeIndex[index]]["x"])
-        orderedNodeY[index] = float(parsedNodeData[orderedNodeIndex[index]]["y"])
+        ## orderedNodeX[index] = float(parsedNodeData[orderedNodeIndex[index]]["x"])
+        ## orderedNodeY[index] = float(parsedNodeData[orderedNodeIndex[index]]["y"])
+        orderedNodeX[index] = parsedNodeData[orderedNodeIndex[index]]["x"]
+        orderedNodeY[index] = parsedNodeData[orderedNodeIndex[index]]["y"]
 
-    lastLinkObject = parsedLinkData[linkObjects[-1]]
+    lastLinkObject = parsedLinkData[linkObjects[l-1]]
     R = sqrt((link["source"]["x"] - lastLinkObject["target"]["x"])**2 + (link["source"]["y"] - lastLinkObject["target"]["y"])**2)
 
     for index in range(N):
@@ -344,16 +354,17 @@ def mainAlgo(dict node, dict link, list parsedNodeData, list parsedLinkData, flo
             if indexing == 0:
                 records.append({'root' : { 'id' : requiredUpdateNode[indexing] ,'pos' :[new_x, new_y]} , 'childNodes' : {}})
                 parsedNodeData[currentNodeIndex].update([("x", new_x), ("y", new_y)])
+                recordLength += 1
             else:
-                records[-1]['childNodes'].update([(requiredUpdateNode[indexing],[new_x, new_y])])
+                records[recordLength -1]['childNodes'].update([(requiredUpdateNode[indexing],[new_x, new_y])])
                 parsedNodeData[currentNodeIndex].update([("x",new_x), ("y",new_y)])
-
+        
         numOfIntersections = calIntersectionNum(parsedLinkData, linkObjects, linkFilteredList)
         if numOfIntersections == 0:
             breakFromWhile  = 1
             break
         """The loss function is defined as : #Intersections  - lambda * dotproduct (which is for measuring the degree of parallelism)"""
-        records[-1]["loss"] = numOfIntersections - LAMBDA*lossFunction(node, binaryVariable, parsedLinkData, nodeIDMapToParsedLinkDataIndexTarget)
+        records[recordLength - 1]["loss"] = numOfIntersections - LAMBDA*lossFunction(node, binaryVariable, parsedLinkData, nodeIDMapToParsedLinkDataIndexTarget) / nodeDepth
         iterations += 1
         realTheta = iterations* THETA