comparison hilbert.cpp @ 35:790939017078

V0.5. Now uses new continuous hilbert curve. HOORAY.

     for(i=0;i<size;i++){
         pwr = size-i;
         bin[i] = (number/(1 << pwr)) % 2;
         bin.push_back(0);
     }
-    
-    
-    
-}
+    return bin;
+    
+    
+}
+//--------------------------------------------------------------------
 void printBool(vector <bool> vcode){
     vector<bool>::iterator bit;
 
         for(bit=vcode.begin(); bit!=vcode.end() ; bit++){
             

     makeRotationRules();
     
     
     // whole process unit test(?)
     
-    unsigned long long inCoord = 888999777;
+    unsigned long long inCoord = 982635920;
     vector<int> checkParam;
     checkParam = calculateParamsFromIndex(inCoord);
     cout << "PARAMS: ";
     for(int i=0; i<P;i++){
         cout << checkParam[i] << " ";
     }
     cout << '\n';
     unsigned long long outCoord = calculateIndexFromParams(checkParam);
-    cout << "Unit TEst coord = " << outCoord << "\n";
+    cout << "UNIT TEST COORD = " << outCoord << "\n";
     
     
 }
 //--------------------------------------------------------------
 void Hilbert::makeRotationRules(){

         // get next highest bits of index
         
         subindex = index >> blev*P;
         subindex = mask & subindex;
         
-        cout << "subindex: " << subindex << "\n";
+        //cout << "subindex: " << subindex << "\n";
         // which vertex corresponds to this index?
         if(subindex < theGrayCode.size()) vertex = theGrayCodeD[subindex];
 
-        cout << "rotated: " << vertex << "\n";
+        //cout << "rotated: " << vertex << "\n";
  
         
         //% inverse rotate this T_e,d
         entryPointInv = rotr(entryPoint, direction+1,P);
         directionInv = (P - direction - 2);
         vertex = rotate(vertex,entryPointInv,directionInv);
 
-        cout << "vertex: " << vertex << "\n";
+        //cout << "vertex: " << vertex << "\n";
         
         //% build up bits of params
      
         for(int j=0;j<P;j++){
             

         }
         // next rotations...
         int lse2 = rotr(newe, P-direction-1,P);
         entryPoint = entryPoint ^ lse2;
         direction = (direction + newd + 1) % P;
-        cout << "------------\n";
+        //cout << "------------\n";
     }
 
     return params;
 }
 //--------------------------------------------------------------------

 }
 //--------------------------------------------------------------------
 
 
 //--------------------------------------------------------------------
-long long Hilbert::calculateIndexFromParams(vector<int> params){
+unsigned long long Hilbert::calculateIndexFromParams(vector<int> params){
     // set  %set start and direction of biggest cube
 
-    long long h = 0;
+    unsigned long long h = 0;
     
     unsigned int i;
     unsigned int entryPoint = 0;
     int direction = P - 1;
-    unsigned int vertex=0, subindex=0, newe=0, newd=0;
-    
+    unsigned int vertex=0,  newe=0, newd=0;
+    unsigned long long subindex; // needs to be long cos we lewt shift by alot
     vector<int> subindices;
 
     
     // for loop thru bit levels
     i=0;

         vector<bool> vertexb;
         for(i=0;i<P;i++){
             vertexb.push_back((params[i]/(1 << blev)) % 2);
             
         }
-        printBool(vertexb);
+        //printBool(vertexb);
         vertex = bin2dec(vertexb);
-        cout << "INV vertex: " << vertex << "\n";
+        //cout << "INV vertex: " << vertex << "\n";
         // rotate it
         vertex = rotate(vertex,entryPoint,direction);
         
         //    % get new index of thisun
-        cout << "INV rotated: " << vertex << "\n";
+        //cout << "INV rotated: " << vertex << "\n";
         
         
         for(i=0;i<codeLength;i++){
             if(vertex == theGrayCodeD[i]){
                 subindex = i;
             }
         }
-        cout << "INV subindex: " << subindex << "\n";
+        //cout << "INV subindex: " << subindex << "\n";
         // work out next rotations
         newe = entryVertices5[subindex];
         newd = rotations5[subindex];
         
         // next rotations...

         entryPoint = entryPoint ^ lse2;
         direction = (direction + newd + 1) % P;
         
         // now build up h from subindices
         h += subindex << (blev*P);
-        cout << "------------\n";
+        //cout << "------------\n";
     }
 
     return h;
 }
 //--------------------------------------------------------------------