Make MDP fully a C++ module too.

osmnx_mdp/algorithms/README.txt

@@ -0,0 +1,5 @@
+Each algorithm implements the Algorithm class.
+Each algorithm consists of:
+* C++ file with the meat of the algorithm
+* pyx file with the Cython wrapper for the C++ module
+* pxd file (Cython header) for easier importing

osmnx_mdp/algorithms/cpp_brtdp.hpp

@@ -1,16 +1,7 @@
 #include <google/dense_hash_map>
 #include <random>
 #include <vector>
-
-
-// TODO: Copied from dstar lite
-struct pair_hash {
-    long long operator () (const std::pair<long, long> &p) const {
-        long long ret = p.first;
-        ret <<= 32;
-        return ret + p.second;
-    }
-};
+#include "cpp_lib.hpp"
 
 
 class CPP_BRTDP {
@@ -30,6 +21,8 @@ class CPP_BRTDP {
         std::vector<long> *S;
         google::dense_hash_map<long, std::vector<std::pair<long, long>>> *A;
         google::dense_hash_map<std::pair<long, long>, float, pair_hash> *C;
+        // It is needed that this is DOUBLE. Especially (B)RTDP
+        // needs precision. Who knows how bad the effect in VI is.
         google::dense_hash_map<
             long,
             google::dense_hash_map<

osmnx_mdp/algorithms/cpp_dstar_lite.hpp

@@ -1,15 +1,8 @@
 #include <google/dense_hash_map>
 #include <set>
 #include <vector>
+#include "cpp_lib.hpp"
 
-// TODO: Copied from testthis.cpp
-struct pair_hash {
-    long long operator () (const std::pair<long, long> &p) const {
-        long long ret = p.first;
-        ret <<= 32;
-        return ret + p.second;
-    }
-};
 
 class cpp_DStar_Lite {
     public:

osmnx_mdp/algorithms/cpp_lib.hpp

@@ -0,0 +1,28 @@
+#ifndef LIB_INCLUDE
+#define LIB_INCLUDE
+
+#include <vector>
+// TODO: Move to ../cpp_lib.hpp
+// Basically create a C++ version of lib.
+
+// TODO: Explain why collisions probably won't happen with this.
+// We assume a 64 bit system.
+// Node numbers sometimes exceed the maximum 32 bit number, which is around
+// 2.1 billion, by a small margin (e.g. 3, 4 or 5 billion). Thus by shifting
+// We lose one number at the front, e.g. 3.1 billion becomes 100 million
+// (before shifting).
+// Since we use this hashing for actions, i.e. the two longs denote the ids of
+// two adjacent nodes, to get a collision, we need to find a node that has as
+// neighbors two numbers that are exactly the same up to their last (most
+// signifcant) digit, the billion digit.
+// This is highly unlikely. // TODO WHY
+// Since we simply add the second number, none of its digits get lost.
+// And with just two ops it's super efficient. Just uses a lot of space.
+struct pair_hash {
+    long long operator () (const std::pair<long, long> &p) const {
+        long long ret = p.first;
+        ret <<= 32;
+        return ret + p.second;
+    }
+};
+#endif