Unbundle gridcodingrange code from htmresearch

Author: mrcslws

README.md

@@ -0,0 +1,10 @@
+# gridcodingrange
+
+## Installation
+
+~~~
+git clone https://github.com/Numenta/gridcodingrange
+cd gridcodingrange
+pip install -r requirements.txt
+pip install .
+~~~

gridcodingrange/__init__.py

@@ -0,0 +1,34 @@
+import _gridcodingrange
+
+import numpy as np
+
+
+def computeGridUniquenessHypercube(domainToPlaneByModule, latticeBasisByModule,
+                                   phaseResolution, ignoredCenterDiameter,
+                                   pingInterval=10.0):
+    domainToPlaneByModule = np.asarray(
+        domainToPlaneByModule, dtype="float64")
+    latticeBasisByModule = np.asarray(
+        latticeBasisByModule, dtype="float64")
+
+    return _gridcodingrange.computeGridUniquenessHypercube(
+        domainToPlaneByModule, latticeBasisByModule, phaseResolution,
+        ignoredCenterDiameter, pingInterval)
+
+
+def computeBinSidelength(domainToPlaneByModule, phaseResolution,
+                         resultPrecision, upperBound=1000.0, timeout=-1.0):
+    domainToPlaneByModule = np.asarray(
+        domainToPlaneByModule, dtype="float64")
+
+    return _gridcodingrange.computeBinSidelength(
+        domainToPlaneByModule, phaseResolution, resultPrecision, upperBound, timeout)
+
+
+def computeBinRectangle(domainToPlaneByModule, phaseResolution,
+                        resultPrecision, upperBound=1000.0, timeout=-1.0):
+    domainToPlaneByModule = np.asarray(
+        domainToPlaneByModule, dtype="float64")
+
+    return _gridcodingrange.computeBinRectangle(
+        domainToPlaneByModule, phaseResolution, resultPrecision, upperBound, timeout)

make-tests.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+
+set -e
+
+cd "$(dirname "$0")"
+
+debug=false
+
+outbin="run-tests"
+
+cmd="g++ -o $outbin ./src/test/main.cpp ./src/test/GridUniquenessTest.cpp ./src/GridUniqueness.cpp ./src/external/gtest/src/gtest-all.cc -I./src -I./src/external -I./src/external/gtest -lpthread"
+
+if [ "$debug" = true ] ; then
+    cmd="$cmd -g -D NTA_ASSERTIONS_ON"
+else
+    cmd="$cmd -O3"
+fi
+
+eval $cmd
+
+echo "To run unit tests, execute: ./$outbin"

requirements.txt

@@ -0,0 +1 @@
+pybind11

setup.py

@@ -0,0 +1,55 @@
+import sys
+from setuptools import setup, Extension
+
+
+class get_pybind_include(object):
+    """Helper class to determine the pybind11 include path
+    The purpose of this class is to postpone importing pybind11
+    until it is actually installed, so that the ``get_include()``
+    method can be invoked. """
+
+    def __init__(self, user=False):
+        self.user = user
+
+    def __str__(self):
+        import pybind11
+        return pybind11.get_include(self.user)
+
+
+sources = [
+    'src/gridcodingrange_module.cpp',
+    'src/GridUniqueness.cpp',
+]
+
+
+compile_args = ["-std=c++14"]
+link_args = []
+
+debug_mode = False
+if debug_mode:
+    compile_args += ["-O0", "-D NTA_ASSERTIONS_ON"]
+else:
+    compile_args += ["-g0"]
+
+
+if sys.platform == "darwin":
+    compile_args += ["-std=c++14", "-mmacosx-version-min=10.10"]
+    link_args += ["-stdlib=libc++", "-mmacosx-version-min=10.10"]
+
+
+module = Extension(
+    '_gridcodingrange',
+    sources=sources,
+    extra_compile_args=compile_args,
+    extra_link_args=link_args,
+    include_dirs=['./src/external',
+                  get_pybind_include(),
+                  get_pybind_include(user=True)]
+)
+
+setup(name='gridcodingrange',
+      version='1.0',
+      description='This is a demo package',
+      packages=['gridcodingrange'],
+      setup_requires=["pybind11"],
+      ext_modules=[module])

src/GridUniqueness.cpp

@@ -24,8 +24,8 @@
  * Implementations for GridUniqueness.hpp
  */
 
-#include <nupic/experimental/GridUniqueness.hpp>
-#include <nupic/utils/Log.hpp>
+#include "GridUniqueness.hpp"
+#include <nta_logging.hpp>
 
 #include <math.h>
 #include <signal.h>

src/GridUniqueness.hpp

@@ -27,7 +27,6 @@
 #ifndef NTA_GRID_UNIQUENESS_HPP
 #define NTA_GRID_UNIQUENESS_HPP
 
-#include <nupic/types/Types.hpp>
 #include <vector>
 #include <utility>
 
@@ -65,12 +64,12 @@ namespace nupic {
        * true if grid code zero is found, false otherwise.
        */
       bool findGridCodeZero(
-        const std::vector<std::vector<std::vector<Real64>>>& domainToPlaneByModule,
-        const std::vector<std::vector<std::vector<Real64>>>& latticeBasisByModule,
-        const std::vector<Real64>& x0,
-        const std::vector<Real64>& dims,
-        Real64 readoutResolution,
-        std::vector<Real64>* pointWithGridCodeZero = nullptr);
+        const std::vector<std::vector<std::vector<double>>>& domainToPlaneByModule,
+        const std::vector<std::vector<std::vector<double>>>& latticeBasisByModule,
+        const std::vector<double>& x0,
+        const std::vector<double>& dims,
+        double readoutResolution,
+        std::vector<double>* pointWithGridCodeZero = nullptr);
 
       /**
        * Given a set of grid cell module parameters, determines the diameter of
@@ -129,12 +128,12 @@ namespace nupic {
        * - The diameter of the hypercube that contains no collisions.
        * - A point just outside this hypercube that collides with the origin.
        */
-      std::pair<Real64,std::vector<Real64>> computeGridUniquenessHypercube(
-        const std::vector<std::vector<std::vector<Real64>>>& domainToPlaneByModule,
-        const std::vector<std::vector<std::vector<Real64>>>& latticeBasisByModule,
-        Real64 readoutResolution,
-        Real64 ignoredCenterDiameter,
-        Real64 pingInterval=10.0);
+      std::pair<double,std::vector<double>> computeGridUniquenessHypercube(
+        const std::vector<std::vector<std::vector<double>>>& domainToPlaneByModule,
+        const std::vector<std::vector<std::vector<double>>>& latticeBasisByModule,
+        double readoutResolution,
+        double ignoredCenterDiameter,
+        double pingInterval=10.0);
 
       /**
        * Compute the sidelength of the smallest hypercube that encloses the
@@ -172,12 +171,12 @@ namespace nupic {
        * The sidelength of this hypercube. Returns -1.0 if a surface can't be
        * found (i.e. if upperBound is reached.)
        */
-      Real64 computeBinSidelength(
-        const std::vector<std::vector<std::vector<Real64>>>& domainToPlaneByModule,
-        Real64 readoutResolution,
-        Real64 resultPrecision,
-        Real64 upperBound = 2048.0,
-        Real64 timeout = -1.0);
+      double computeBinSidelength(
+        const std::vector<std::vector<std::vector<double>>>& domainToPlaneByModule,
+        double readoutResolution,
+        double resultPrecision,
+        double upperBound = 2048.0,
+        double timeout = -1.0);
 
       /**
        * Like computeBinSidelength, but it computes a hyperrectangle rather than
@@ -214,12 +213,12 @@ namespace nupic {
        * The dimensions of this hyperrectangle. Returns an empty vector if a
        * surface can't be found (i.e. if upperBound is reached.)
        */
-      std::vector<Real64> computeBinRectangle(
-        const std::vector<std::vector<std::vector<Real64>>>& domainToPlaneByModule,
-        Real64 readoutResolution,
-        Real64 resultPrecision,
-        Real64 upperBound = 2048.0,
-        Real64 timeout = -1.0);
+      std::vector<double> computeBinRectangle(
+        const std::vector<std::vector<std::vector<double>>>& domainToPlaneByModule,
+        double readoutResolution,
+        double resultPrecision,
+        double upperBound = 2048.0,
+        double timeout = -1.0);
     }
   }
 }

src/external/boost/algorithm/minmax.hpp

@@ -0,0 +1,47 @@
+//  (C) Copyright Herve Bronnimann 2004.
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+/*
+ Revision history:
+   1 July 2004
+      Split the code into two headers to lessen dependence on
+      Boost.tuple. (Herve)
+   26 June 2004
+      Added the code for the boost minmax library. (Herve)
+*/
+
+#ifndef BOOST_ALGORITHM_MINMAX_HPP
+#define BOOST_ALGORITHM_MINMAX_HPP
+
+/* PROPOSED STANDARD EXTENSIONS:
+ *
+ * minmax(a, b)
+ * Effect: (b<a) ? std::make_pair(b,a) : std::make_pair(a,b);
+ *
+ * minmax(a, b, comp)
+ * Effect: comp(b,a) ? std::make_pair(b,a) : std::make_pair(a,b);
+ *
+ */
+
+#include <boost/tuple/tuple.hpp> // for using pairs with boost::cref
+#include <boost/ref.hpp>
+
+namespace boost {
+
+  template <typename T>
+  tuple< T const&, T const& >
+  minmax(T const& a, T const& b) {
+    return (b<a) ? make_tuple(cref(b),cref(a)) : make_tuple(cref(a),cref(b));
+  }
+
+  template <typename T, class BinaryPredicate>
+  tuple< T const&, T const& >
+  minmax(T const& a, T const& b, BinaryPredicate comp) {
+    return comp(b,a) ? make_tuple(cref(b),cref(a)) : make_tuple(cref(a),cref(b));
+  }
+
+} // namespace boost
+
+#endif // BOOST_ALGORITHM_MINMAX_HPP