Skip to content
This repository has been archived by the owner on Sep 1, 2023. It is now read-only.

Commit

Permalink
Unbundle GridUniqueness code into gridcodingrange library
Browse files Browse the repository at this point in the history
  • Loading branch information
@mrcslws
mrcslws committed Jul 22, 2019
1 parent 6146fa7 commit 81296a9
Show file tree
Hide file tree
Showing 5 changed files with 0 additions and 3,666 deletions.
15 changes: 0 additions & 15 deletions src/CMakeLists.txt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -239,14 +239,6 @@ set(src_htmresearchcore_srcs
nupic/experimental/SDRSelection.cpp
)

if(NOT MINGW)
# This file uses threading that's not available in our version of MINGW.
set(src_htmresearchcore_srcs
${src_htmresearchcore_srcs}
nupic/experimental/GridUniqueness.cpp
)
endif()

set(src_lib_static_htmresearchcore_srcs
${src_capnp_generated_srcs}
${src_htmresearchcore_srcs})
Expand Down Expand Up @@ -313,13 +305,6 @@ set(src_htmresearch_core_gtest_srcs
test/unit/UnitTestMain.cpp
test/unit/utils/GroupByTest.cpp
)
if(NOT MINGW)
# This file uses threading that's not available in our version of MINGW.
set(src_htmresearch_core_gtest_srcs
${src_htmresearch_core_gtest_srcs}
test/unit/experimental/GridUniquenessTest.cpp
)
endif()
add_executable(${src_executable_gtests}
${src_htmresearch_core_gtest_srcs}
)
Expand Down
187 changes: 0 additions & 187 deletions src/nupic/bindings/experimental.i
View file
Original file line number Diff line number Diff line change
Expand Up @@ -127,193 +127,6 @@ using namespace nupic;

%naturalvar;

#ifndef NTA_OS_WINDOWS

// computeGridUniquenessHypercube uses threading that's not available in our
// MINGW Windows build system.

%{
#include <nupic/experimental/GridUniqueness.hpp>
%}

%pythoncode %{
def computeGridUniquenessHypercube(domainToPlaneByModule, latticeBasisByModule,
phaseResolution, ignoredCenterDiameter,
pingInterval=10.0):
domainToPlaneByModule = numpy.asarray(domainToPlaneByModule, dtype="float64")
latticeBasisByModule = numpy.asarray(latticeBasisByModule, dtype="float64")

return _computeGridUniquenessHypercube(
domainToPlaneByModule, latticeBasisByModule, phaseResolution,
ignoredCenterDiameter, pingInterval)
%}

%inline {
PyObject* _computeGridUniquenessHypercube(PyObject* py_domainToPlaneByModule,
PyObject* py_latticeBasisByModule,
Real64 phaseResolution,
Real64 ignoredCenterDiameter,
Real64 pingInterval)
{
PyArrayObject* pyArr_domainToPlaneByModule =
(PyArrayObject*)py_domainToPlaneByModule;
NTA_CHECK(PyArray_NDIM(pyArr_domainToPlaneByModule) == 3);
npy_intp* npy_dims = PyArray_DIMS(pyArr_domainToPlaneByModule);

std::vector<std::vector<std::vector<Real64>>> domainToPlaneByModule;
for (size_t i = 0; i < npy_dims[0]; i++)
{
std::vector<std::vector<Real64>> module;
for (size_t j = 0; j < npy_dims[1]; j++)
{
std::vector<Real64> row;
for (size_t k = 0; k < npy_dims[2]; k++)
{
row.push_back(*(Real64*)PyArray_GETPTR3(pyArr_domainToPlaneByModule,
i, j, k));
}
module.push_back(row);
}
domainToPlaneByModule.push_back(module);
}

PyArrayObject* pyArr_latticeBasisByModule =
(PyArrayObject*)py_latticeBasisByModule;
NTA_CHECK(PyArray_NDIM(pyArr_latticeBasisByModule) == 3);
npy_dims = PyArray_DIMS(pyArr_latticeBasisByModule);

std::vector<std::vector<std::vector<Real64>>> latticeBasisByModule;
for (size_t i = 0; i < npy_dims[0]; i++)
{
std::vector<std::vector<Real64>> module;
for (size_t j = 0; j < npy_dims[1]; j++)
{
std::vector<Real64> row;
for (size_t k = 0; k < npy_dims[2]; k++)
{
row.push_back(*(Real64*)PyArray_GETPTR3(pyArr_latticeBasisByModule,
i, j, k));
}
module.push_back(row);
}
latticeBasisByModule.push_back(module);
}

std::pair<Real64,std::vector<Real64>> result =
nupic::experimental::grid_uniqueness::computeGridUniquenessHypercube(
domainToPlaneByModule, latticeBasisByModule, phaseResolution,
ignoredCenterDiameter, pingInterval);

PyObject* pyResult = PyTuple_New(2);
PyTuple_SetItem(pyResult, 0, PyFloat_FromDouble(result.first));
PyTuple_SetItem(pyResult, 1, nupic::NumpyVectorT<Real64>(result.second.size(),
result.second.data())
.forPython());

return pyResult;
}
}


%pythoncode %{
def computeBinSidelength(domainToPlaneByModule, phaseResolution,
resultPrecision, upperBound=1000.0, timeout=-1.0):
domainToPlaneByModule = numpy.asarray(domainToPlaneByModule, dtype="float64")

return _computeBinSidelength(
domainToPlaneByModule, phaseResolution, resultPrecision, upperBound, timeout)
%}

%inline {
PyObject* _computeBinSidelength(PyObject* py_domainToPlaneByModule,
Real64 readoutResolution,
Real64 resultPrecision,
Real64 upperBound,
Real64 timeout)
{
PyArrayObject* pyArr_domainToPlaneByModule =
(PyArrayObject*)py_domainToPlaneByModule;
NTA_CHECK(PyArray_NDIM(pyArr_domainToPlaneByModule) == 3);
npy_intp* npy_dims = PyArray_DIMS(pyArr_domainToPlaneByModule);

std::vector<std::vector<std::vector<Real64>>> domainToPlaneByModule;
for (size_t i = 0; i < npy_dims[0]; i++)
{
std::vector<std::vector<Real64>> module;
for (size_t j = 0; j < npy_dims[1]; j++)
{
std::vector<Real64> row;
for (size_t k = 0; k < npy_dims[2]; k++)
{
row.push_back(*(Real64*)PyArray_GETPTR3(pyArr_domainToPlaneByModule,
i, j, k));
}
module.push_back(row);
}
domainToPlaneByModule.push_back(module);
}

Real64 result =
nupic::experimental::grid_uniqueness::computeBinSidelength(
domainToPlaneByModule, readoutResolution, resultPrecision,
upperBound, timeout);

return PyFloat_FromDouble(result);
}
}

%pythoncode %{
def computeBinRectangle(domainToPlaneByModule, phaseResolution,
resultPrecision, upperBound=1000.0, timeout=-1.0):
domainToPlaneByModule = numpy.asarray(domainToPlaneByModule, dtype="float64")

return _computeBinRectangle(
domainToPlaneByModule, phaseResolution, resultPrecision, upperBound, timeout)
%}

%inline {
PyObject* _computeBinRectangle(PyObject* py_domainToPlaneByModule,
Real64 readoutResolution,
Real64 resultPrecision,
Real64 upperBound,
Real64 timeout)
{
PyArrayObject* pyArr_domainToPlaneByModule =
(PyArrayObject*)py_domainToPlaneByModule;
NTA_CHECK(PyArray_NDIM(pyArr_domainToPlaneByModule) == 3);
npy_intp* npy_dims = PyArray_DIMS(pyArr_domainToPlaneByModule);

std::vector<std::vector<std::vector<Real64>>> domainToPlaneByModule;
for (size_t i = 0; i < npy_dims[0]; i++)
{
std::vector<std::vector<Real64>> module;
for (size_t j = 0; j < npy_dims[1]; j++)
{
std::vector<Real64> row;
for (size_t k = 0; k < npy_dims[2]; k++)
{
row.push_back(*(Real64*)PyArray_GETPTR3(pyArr_domainToPlaneByModule,
i, j, k));
}
module.push_back(row);
}
domainToPlaneByModule.push_back(module);
}

std::vector<Real64> result =
nupic::experimental::grid_uniqueness::computeBinRectangle(
domainToPlaneByModule, readoutResolution, resultPrecision,
upperBound, timeout);

return nupic::NumpyVectorT<Real64>(result.size(),
result.data()).forPython();
}
}



#endif NTA_OS_WINDOWS

//--------------------------------------------------------------------------------
// Apical Tiebreak Temporal Memory
//--------------------------------------------------------------------------------
Expand Down
Loading

0 comments on commit 81296a9

Please sign in to comment.