Connections better use typedefed types Segment, Synapse, ...

bindings/py/cpp_src/bindings/algorithms/py_HTM.cpp

@@ -44,7 +44,7 @@ namespace nupic_ext
 namespace py = pybind11;
 using namespace nupic;
 using nupic::sdr::SDR;
-using nupic::algorithms::connections::Permanence; 
+using namespace nupic::algorithms::connections; 
 
     void init_HTM(py::module& m)
     {
@@ -53,14 +53,21 @@ using nupic::algorithms::connections::Permanence;
         py::class_<HTM_t> py_HTM(m, "TemporalMemory");
 
         py_HTM.def(py::init<>());
-        py_HTM.def(py::init<std::vector<UInt>
-                , UInt, UInt
-                , Permanence, Permanence
-                , UInt, UInt
-                , Permanence, Permanence, Permanence
+        py_HTM.def(py::init<std::vector<CellIdx>
+	        , CellIdx
+		, SynapseIdx
+                , Permanence
+		, Permanence
+                , SynapseIdx
+		, SynapseIdx
+                , Permanence
+		, Permanence
+		, Permanence
                 , Int
-                , UInt, UInt
-                , bool, UInt>()
+                , SegmentIdx
+		, SynapseIdx
+                , bool
+		, UInt>()
                 , py::arg("columnDimensions")
                 , py::arg("cellsPerColumn") = 32
                 , py::arg("activationThreshold") = 13
@@ -151,16 +158,12 @@ using nupic::algorithms::connections::Permanence;
 
         py_HTM.def("getActiveSegments", [](const HTM_t& self)
         {
-            auto activeSegments = self.getActiveSegments();
-
-            return py::array_t<nupic::UInt32>(activeSegments.size(), activeSegments.data());
+            return self.getActiveSegments();
         });
 
         py_HTM.def("getMatchingSegments", [](const HTM_t& self)
         {
-            auto matchingSegments = self.getMatchingSegments();
-
-            return py::array_t<nupic::UInt32>(matchingSegments.size(), matchingSegments.data());
+            return self.getMatchingSegments();
         });
 
         py_HTM.def("cellsForColumn", [](HTM_t& self, UInt columnIdx)

bindings/py/cpp_src/bindings/algorithms/py_SpatialPooler.cpp

@@ -273,7 +273,7 @@ namespace nupic_ext
         {
             auto overlaps = self.getOverlaps();
 
-            return py::array_t<UInt>( overlaps.size(), overlaps.data());
+            return py::array_t<SynapseIdx>( overlaps.size(), overlaps.data());
         });
 
         // getBoostedOverlaps

src/nupic/algorithms/Connections.cpp

@@ -83,11 +83,13 @@ void Connections::unsubscribe(UInt32 token) {
 
 Segment Connections::createSegment(CellIdx cell) {
   Segment segment;
-  if (destroyedSegments_.size() > 0) {
+  if (!destroyedSegments_.empty() ) { //reuse old, destroyed segs
     segment = destroyedSegments_.back();
     destroyedSegments_.pop_back();
-  } else {
-    segment = (Segment)segments_.size();
+  } else { //create a new segment
+    NTA_CHECK(segments_.size() < std::numeric_limits<Segment>::max()) << "Add segment failed: Range of Segment (data-type) insufficinet size."
+	    << (size_t)segments_.size() << " < " << (size_t)std::numeric_limits<Segment>::max();
+    segment = static_cast<Segment>(segments_.size());
     segments_.push_back(SegmentData());
     segmentOrdinals_.push_back(0);
   }
@@ -112,11 +114,13 @@ Synapse Connections::createSynapse(Segment segment,
                                    Permanence permanence) {
   // Get an index into the synapses_ list, for the new synapse to reside at.
   Synapse synapse;
-  if (destroyedSynapses_.size() > 0) {
+  if (!destroyedSynapses_.empty() ) {
     synapse = destroyedSynapses_.back();
     destroyedSynapses_.pop_back();
   } else {
-    synapse = (UInt)synapses_.size();
+    NTA_CHECK(synapses_.size() < std::numeric_limits<Synapse>::max()) << "Add synapse failed: Range of Synapse (data-type) insufficient size."
+	    << synapses_.size() << " < " << (size_t)std::numeric_limits<Synapse>::max();
+    synapse = static_cast<Synapse>(synapses_.size());
     synapses_.push_back(SynapseData());
     synapseOrdinals_.push_back(0);
   }
@@ -166,7 +170,7 @@ bool Connections::synapseExists_(Synapse synapse) const {
  * last synapse in the list over this synapse.
  */
 void Connections::removeSynapseFromPresynapticMap_(
-    const UInt index,
+    const Synapse index,
     vector<Synapse> &preSynapses,
     vector<Segment> &preSegments)
 {
@@ -267,19 +271,23 @@ void Connections::updateSynapsePermanence(Synapse synapse,
   permanence = std::max(permanence, minPermanence );
 
   auto &synData = synapses_[synapse];
-  bool before = synData.permanence >= connectedThreshold_;
-  bool after  = permanence         >= connectedThreshold_;
+
+  const bool before = synData.permanence >= connectedThreshold_;
+  const bool after  = permanence         >= connectedThreshold_;
   synData.permanence = permanence;
 
-  if( before != after ) {
+  if( before == after ) { //no change
+      return;
+  }
     const auto &presyn    = synData.presynapticCell;
     auto &potentialPresyn = potentialSynapsesForPresynapticCell_[presyn];
     auto &potentialPreseg = potentialSegmentsForPresynapticCell_[presyn];
     auto &connectedPresyn = connectedSynapsesForPresynapticCell_[presyn];
     auto &connectedPreseg = connectedSegmentsForPresynapticCell_[presyn];
     const auto &segment   = synData.segment;
     auto &segmentData     = segments_[segment];
-    if( after ) {
+
+    if( after ) { //connect
       segmentData.numConnected++;
 
       // Remove this synapse from presynaptic potential synapses.
@@ -291,7 +299,7 @@ void Connections::updateSynapsePermanence(Synapse synapse,
       connectedPresyn.push_back( synapse );
       connectedPreseg.push_back( segment );
     }
-    else {
+    else { //disconnected
       segmentData.numConnected--;
 
       // Remove this synapse from presynaptic connected synapses.
@@ -304,10 +312,9 @@ void Connections::updateSynapsePermanence(Synapse synapse,
       potentialPreseg.push_back( segment );
     }
 
-    for (auto h : eventHandlers_) {
+    for (auto h : eventHandlers_) { //TODO handle callbacks in performance-critical method only in Debug?
       h.second->onUpdateSynapsePermanence(synapse, permanence);
     }
-  }
 }
 
 const vector<Segment> &Connections::segmentsForCell(CellIdx cell) const {
@@ -358,9 +365,7 @@ const SynapseData &Connections::dataForSynapse(Synapse synapse) const {
   return synapses_[synapse];
 }
 
-UInt32 Connections::segmentFlatListLength() const { return (UInt32)segments_.size(); }
-
-bool Connections::compareSegments(Segment a, Segment b) const {
+bool Connections::compareSegments(const Segment a, const Segment b) const {
   const SegmentData &aData = segments_[a];
   const SegmentData &bData = segments_[b];
   if (aData.cell < bData.cell) {
@@ -385,24 +390,24 @@ Connections::synapsesForPresynapticCell(CellIdx presynapticCell) const {
 
 
 void Connections::computeActivity(
-    vector<UInt32> &numActiveConnectedSynapsesForSegment,
+    vector<SynapseIdx> &numActiveConnectedSynapsesForSegment,
     const vector<CellIdx> &activePresynapticCells) const
 {
   NTA_ASSERT(numActiveConnectedSynapsesForSegment.size() == segments_.size());
 
   // Iterate through all connected synapses.
-  for (CellIdx cell : activePresynapticCells) {
+  for (const auto& cell : activePresynapticCells) {
     if (connectedSegmentsForPresynapticCell_.count(cell)) {
-      for( Segment segment : connectedSegmentsForPresynapticCell_.at(cell)) {
+      for(const auto& segment : connectedSegmentsForPresynapticCell_.at(cell)) {
         ++numActiveConnectedSynapsesForSegment[segment];
       }
     }
   }
 }
 
 void Connections::computeActivity(
-    vector<UInt32> &numActiveConnectedSynapsesForSegment,
-    vector<UInt32> &numActivePotentialSynapsesForSegment,
+    vector<SynapseIdx> &numActiveConnectedSynapsesForSegment,
+    vector<SynapseIdx> &numActivePotentialSynapsesForSegment,
     const vector<CellIdx> &activePresynapticCells) const {
   NTA_ASSERT(numActiveConnectedSynapsesForSegment.size() == segments_.size());
   NTA_ASSERT(numActivePotentialSynapsesForSegment.size() == segments_.size());
@@ -416,9 +421,9 @@ void Connections::computeActivity(
   std::copy( numActiveConnectedSynapsesForSegment.begin(),
              numActiveConnectedSynapsesForSegment.end(),
              numActivePotentialSynapsesForSegment.begin());
-  for (CellIdx cell : activePresynapticCells) {
+  for (const auto& cell : activePresynapticCells) {
     if (potentialSegmentsForPresynapticCell_.count(cell)) {
-      for( Segment segment : potentialSegmentsForPresynapticCell_.at(cell)) {
+      for(const auto& segment : potentialSegmentsForPresynapticCell_.at(cell)) {
         ++numActivePotentialSynapsesForSegment[segment];
       }
     }
@@ -502,7 +507,7 @@ void Connections::raisePermanencesToThreshold(
 
   // Raise the permance of all synapses in the potential pool uniformly.
   for( const auto &syn : synapses ) //TODO vectorize: vector + const to all members
-    updateSynapsePermanence(syn, synapses_[syn].permanence + increment);
+    updateSynapsePermanence(syn, synapses_[syn].permanence + increment); //this is performance HOTSPOT
 }
 
 
@@ -561,7 +566,7 @@ void Connections::load(std::istream &inStream) {
   // Check the saved version.
   int version;
   inStream >> version;
-  NTA_CHECK(version <= 2);
+  NTA_CHECK(version == 2);
 
   // Retrieve simple variables
   UInt        numCells;
@@ -570,22 +575,13 @@ void Connections::load(std::istream &inStream) {
   inStream >> connectedThreshold;
   initialize(numCells, connectedThreshold);
 
-  // This logic is complicated by the fact that old versions of the Connections
-  // serialized "destroyed" segments and synapses, which we now ignore.
   for (UInt cell = 0; cell < numCells; cell++) {
 
     UInt numSegments;
     inStream >> numSegments;
 
     for (SegmentIdx j = 0; j < numSegments; j++) {
-      bool destroyedSegment = false;
-      if (version < 2) {
-        inStream >> destroyedSegment;
-      }
-
-      Segment segment = {(UInt32)-1};
-      if (!destroyedSegment)
-        segment = createSegment( cell );
+      Segment segment = createSegment( cell );
 
       UInt numSynapses;
       inStream >> numSynapses;
@@ -596,15 +592,6 @@ void Connections::load(std::istream &inStream) {
         inStream >> presyn;
         inStream >> perm;
 
-        if (version < 2) {
-          bool destroyedSynapse = false;
-          inStream >> destroyedSynapse;
-          if( destroyedSynapse )
-            continue;
-        }
-        if( destroyedSegment )
-          continue;
-
         createSynapse( segment, presyn, perm );
       }
     }
@@ -615,51 +602,33 @@ void Connections::load(std::istream &inStream) {
 }
 
 
-CellIdx Connections::numCells() const { return (CellIdx)cells_.size(); }
-
-UInt Connections::numSegments() const {
-  return (UInt)(segments_.size() - destroyedSegments_.size());
-}
-
-UInt Connections::numSegments(CellIdx cell) const {
-  return (UInt)cells_[cell].segments.size();
-}
-
-UInt Connections::numSynapses() const {
-  return (UInt)(synapses_.size() - destroyedSynapses_.size());
-}
-
-UInt Connections::numSynapses(Segment segment) const {
-  return (UInt)segments_[segment].synapses.size();
-}
-
 bool Connections::operator==(const Connections &other) const {
   if (cells_.size() != other.cells_.size())
     return false;
 
-  for (CellIdx i = 0; i < cells_.size(); ++i) {
+  for (CellIdx i = 0; i < static_cast<CellIdx>(cells_.size()); i++) {
     const CellData &cellData = cells_[i];
     const CellData &otherCellData = other.cells_[i];
 
     if (cellData.segments.size() != otherCellData.segments.size()) {
       return false;
     }
 
-    for (SegmentIdx j = 0; j < (SegmentIdx)cellData.segments.size(); ++j) {
-      Segment segment = cellData.segments[j];
+    for (SegmentIdx j = 0; j < static_cast<SegmentIdx>(cellData.segments.size()); j++) {
+      const Segment segment = cellData.segments[j];
       const SegmentData &segmentData = segments_[segment];
-      Segment otherSegment = otherCellData.segments[j];
+      const Segment otherSegment = otherCellData.segments[j];
       const SegmentData &otherSegmentData = other.segments_[otherSegment];
 
       if (segmentData.synapses.size() != otherSegmentData.synapses.size() ||
           segmentData.cell != otherSegmentData.cell) {
         return false;
       }
 
-      for (SynapseIdx k = 0; k < (SynapseIdx)segmentData.synapses.size(); ++k) {
-        Synapse synapse = segmentData.synapses[k];
+      for (SynapseIdx k = 0; k < static_cast<SynapseIdx>(segmentData.synapses.size()); k++) {
+        const Synapse synapse = segmentData.synapses[k];
         const SynapseData &synapseData = synapses_[synapse];
-        Synapse otherSynapse = otherSegmentData.synapses[k];
+        const Synapse otherSynapse = otherSegmentData.synapses[k];
         const SynapseData &otherSynapseData = other.synapses_[otherSynapse];
 
         if (synapseData.presynapticCell != otherSynapseData.presynapticCell ||
@@ -677,6 +646,3 @@ bool Connections::operator==(const Connections &other) const {
   return true;
 }
 
-bool Connections::operator!=(const Connections &other) const {
-  return !(*this == other);
-}