Document goto/come-from(-like) behavior. Clean up junk code comments.

diff --git a/ham_ss.cpp b/ham_ss.cpp
index 0fb6dad..c02ee9c 100644 (file)
--- a/ham_ss.cpp
+++ b/ham_ss.cpp
@@ -294,14 +294,12 @@ unsigned PottsHamiltonian::insertReferenceStates()
 {
     // find indices of singular states
     std::vector<unsigned> Xidx;
-    //Xidx.push_back(0);      // prepend with 0, for starting interval
     for (unsigned i = 0; i < state2aa.size(); ++i) {
         if (state2aa[i].size() == 1) {  // state2aa[i] == {aa_X}
             Xidx.push_back(i);
         }
     }
-    //Xidx.push_back(size);   // append with size, for ending interval
-    unsigned numX = Xidx.size(); // - 2;
+    unsigned numX = Xidx.size();
     unsigned sizeOld = size - numX;
     //assert(J.size() == (sizeOld+1)*(sizeOld)/2);
 
@@ -310,18 +308,9 @@ unsigned PottsHamiltonian::insertReferenceStates()
         return 0;
 
     Coupling newJ;
-    //newJ.reserve(J.size() + numX*size - numX*(numX-1)/2);
     newJ.reserve(size*(size+1)/2);
 
     Coupling::iterator Jbegin = J.begin();
-    //Coupling::iterator end = J.begin();
-
-    //// iterate over 
-    //for (size_t i = 0; i < numX; ++i) {
-    //    for (size_t j = i+1; j < numX; ++j) {
-
-    //    }
-    //}
 
     unsigned inserted = 0;
 
@@ -330,66 +319,46 @@ unsigned PottsHamiltonian::insertReferenceStates()
     unsigned Xdone = 0;
     unsigned sectionBeg = 0;
     bool copyToEnd = true;
-    //unsigned dstBeg = 0;
-    //unsigned dstEnd = 0;
+
     // iterate over regions in the destination vector
     for (unsigned sec = 0; sec < size; ++sec) {
-        unsigned secLen = size - sec;   // dst
-        //dstBeg = index(sec,sec+1,size) - size + sec;
-        //equivalently, srcBeg = srcEnd; ... but this may prevent loop unrolling?
-        //srcBeg = index(sec,sec+1,sizeOld) - sizeOld + sec;
-        //srcEnd = srcBeg;
         srcBeg = srcEnd;    // need to start at end of last one
+        // could probably calculate as something like index(sec-Xdone,sec-Xdone+1,sizeOld - sizeOld + sec
         sectionBeg = srcBeg;
-        copyToEnd = true;
-        //dstBeg = index(sec,sec+1,size) - secLen;
         for (unsigned i = Xdone; i < numX; ++i) {
             if (sec <= Xidx[i]) {
-                srcEnd = sectionBeg + Xidx[i] + Xdone - i - sec;
                 // copy
+                srcEnd = sectionBeg + Xidx[i] + Xdone - i - sec;
                 newJ.insert(newJ.end(), Jbegin+srcBeg, Jbegin+srcEnd);
                 newJ.push_back(std::vector<double>());
                 inserted += 1;
-                // copy from begin to Xidx[i]-sec
-                // copy Xidx[i-1],Xidx[i] + i-1;
                 srcBeg = srcEnd;
             }
             else if (sec == Xidx[i]+1) {
                 // insert a whole bunch of nothings
+                unsigned secLen = size - sec;   // dst
                 newJ.insert(newJ.end(), secLen, std::vector<double>());
                 inserted += secLen;
                 ++Xdone;    // skip this index in subsequent blocks
-                copyToEnd = false;
+                copyToEnd = false;  // goto below
                 break;
-                //for (size_t k = 0; k < secLen; ++k)
-                //    newJ.push_back(std::vector<double>());
             }
-            //dstBeg = dstEnd;
-            //srcBeg = srcEnd;
             // TODO: consider using a deque and Xidx.pop_front()
         }
         if (copyToEnd) {
-            //end = J.begin() + (size-sec)*(size-sec-1)/2;  // or something
-            //dstEnd = index(sec,sec+1,size);
             srcEnd = index(sec-Xdone,sec-Xdone+1,sizeOld);
             // copy from begin to end of section
             newJ.insert(newJ.end(), Jbegin+srcBeg, Jbegin+srcEnd);
         }
+        else {
+            copyToEnd = true;   // come from above
+        }
     }
 
     if (inserted != numX*size - numX*(numX-1)/2) {
         std::cerr << "ERROR in insertReferenceStates: incorrectly calculated padding" << std::endl;
         throw "incorrectly calculated correction....";
     }
-    //for (size_t idx = 0; idx < Xidx.size(); ++idx) {
-    //    i = Xidx[idx];
-    //    end += i;
-
-    //        end += i;
-    //        newJ.insert(newJ.end(),begin,end);  // copy range [begin,end)
-    //        newJ.push_back(std::vector<double>());  // add dummy entry
-    //        begin += i;     // next copy starts here
-    //        inserted++;
 
     J.assign(newJ.begin(),newJ.end());