Changes to avoid type-size and signed/unsigned conversion compiler warnings on Windows. In:

1, hammingdistance.h - lots of initializations to {0} and 0 (at least, in Windows builds), e.g. in ALIGN_32
2. clustertree.h - made the clusterIndex member of Link an intptr_t.
3. clustertree.h - explicitly created a local LeafDistance instance to avoid a weird emplace_back() error
    (I couldn't figure out what the compiler was upset about!)
4. clustertree.h - writeTreeToFile explicitly use std::ios_base::openmode ?! Why did I have to?!
5. nj,h - in getRowMinima() added some explicit initializations (to avoid warnings from the linter)
6. rapidnj.h - in getRowMinimum(), likewise.
7. rapidnj.h - in getRowMinimum(), declared a local b_plus_1 variable (!) (weird linter overflow "risk" warning).
8. stitchup.cpp - as for 4 above (writeTreeToFIle explicitly uses std::ios_base::openmode.
9, stitchup.cpp - some useless initializations, coz Visual Studio's linter can't tell do/while from while?

Author: JamesBarbetti

.gitignore

@@ -3,10 +3,10 @@
 .settings
 .project
 .vs
-Debug
 x64
-decentTree.vcxproj.user
+Debug
 build/
+decentTree.vcxproj.user
 james_notes.txt
 pydecenttree/dist
 pydecenttree/pydecenttree.egg-info

clustertree.h

@@ -41,8 +41,8 @@ template <class T=double> struct Link {
     //a cluster (clusters are identified by index).
     //
 public:
-    size_t  clusterIndex;
-    T       linkDistance;
+    intptr_t clusterIndex;
+    T        linkDistance;
     Link(size_t index, T distance) 
         : clusterIndex(index), linkDistance(distance) {
     }
@@ -127,7 +127,10 @@ template <class T> class ClusterTree: public std::vector<Cluster<T>>
                                     LeafDistanceVector& ldv) {
         //Running time proportional to subtree size
         std::vector<LeafDistance> stack;
-        stack.emplace_back(top, branch_length);
+        LeafDistance top_node;
+        top_node.first  = top;
+        top_node.second = branch_length;
+        stack.emplace_back(top_node);
         while (!stack.empty()) {
             LeafDistance b = stack.back();
             stack.pop_back();
@@ -225,7 +228,7 @@ template <class T> class ClusterTree: public std::vector<Cluster<T>>
                          F& out) const {
         out.exceptions(std::ios::failbit | std::ios::badbit);
         try {
-            auto openMode = isOutputToBeAppended
+            std::ios_base::openmode openMode = isOutputToBeAppended
                           ? std::ios_base::app : std::ios_base::trunc;
             openMode |= std::ios_base::out;  
             out.open(treeFilePath.c_str(), openMode );

nj.h

@@ -461,12 +461,15 @@ class VectorizedMatrix: public SUPER
                      //from which that value came.
 
             intptr_t colStop = row - blockSize;
+            V  rowVector(0);
+            V  totVector(0);
+            V  numVector(0);
             for (col=0; col<colStop; col+=blockSize) {
-                V  rowVector; rowVector.load_a(rowData+col);
-                V  totVector; totVector.load_a(tot+col);
+                rowVector.load_a(rowData+col);
+                totVector.load_a(tot+col);
                 V  adjVector = rowVector - totVector;
                 VB less      = adjVector < minVector;
-                V  numVector; numVector.load_a(nums+col);
+                numVector.load_a(nums+col);
                 ixVector     = select(less, numVector, ixVector);
                 minVector    = select(less, adjVector, minVector);
             }

rapidnj.h

@@ -379,8 +379,9 @@ class BoundingMatrix: public SUPER
         #endif
         for (int b=0; b<threadCount; ++b) {
             T      qBestForThread = qBest;
-            size_t rStart         = (b*rSize)     / threadCount;
-            size_t rStop          = ((b+1)*rSize) / threadCount;
+            int    b_plus_1       = (b + 1);
+            size_t rStart         = (b*rSize)        / threadCount;
+            size_t rStop          = (b_plus_1*rSize) / threadCount;
             for (size_t r=rStart; r < rStop
                     && rowMinima[r].value < infiniteDistance; ++r) {
                 intptr_t rowA     = rowMinima[r].row;
@@ -649,16 +650,19 @@ class VectorizedBoundingMatrix: public SUPER
 
         V    best_hc_vector ((T)(infiniteDistance));
         V    best_ix_vector ((T)(-1));
+        V    raw(0);
+        V    c_tot(0);
+        V    ix(0);
 
         for (size_t i=0; i<v_partners; i+=block_size) {
             for (int j=0; j<block_size; ++j) {
                 int k = toCluster[i+j];
                 blockCluster[j] = tot[k];
                 blockIndex[j]   = (T)k;
             }
-            V  raw;    raw.load(rowData+i);
-            V  c_tot;  c_tot.load(blockCluster);
-            V  ix;     ix.load(blockIndex);
+            raw.load(rowData+i);
+            c_tot.load(blockCluster);
+            ix.load(blockIndex);
             V  hc   = raw - c_tot; //subtract cluster totals to get half-cooked distances?
             VB less = hc < best_hc_vector; //which are improvements?
             best_hc_vector = select(less, hc, best_hc_vector);

starttree.h

@@ -199,7 +199,7 @@ namespace StartTree
                 return false;
             }
             constructTreeWith(builder);
-            double rms;
+            double rms = 0;
             if (!silent && builder.calculateRMSOfTMinusD(distanceMatrix, 
                                                          sequenceNames.size(), rms)) {
                 std::cout << "Root Mean Square Error was " << rms << std::endl;

stitchup.cpp

@@ -363,7 +363,7 @@ template <class T=double> struct StitchupGraph {
     bool writeTreeToFile(int precision, const std::string &treeFilePath, 
                          bool isFileToBeOpenedForAppending, 
                          bool subtreeOnly, F& out) const {
-        bool success = false;
+        bool success = false;           
         std::string desc = "Writing STITCH tree to ";
         desc+=treeFilePath;
         #if USE_PROGRESS_DISPLAY
@@ -373,7 +373,7 @@ template <class T=double> struct StitchupGraph {
         #endif
         out.exceptions(std::ios::failbit | std::ios::badbit);
         try {
-            auto openMode = isFileToBeOpenedForAppending
+            std::ios_base::openmode openMode = isFileToBeOpenedForAppending
                           ? std::ios_base::app : std::ios_base::trunc;
             openMode |= std::ios_base::out;  
             out.open(treeFilePath.c_str(), openMode);
@@ -564,8 +564,8 @@ template < class T=double> class StitchupMatrix: public SquareMatrix<T> {
         #endif
         for (intptr_t join = 0; join + 1 < row_count; ++join) {
             LengthSortedStitch<T> shortest;
-            size_t source;
-            size_t dest;
+            size_t source = 0;
+            size_t dest   = 0;
             do {
                 shortest = heap.pop_min();
                 source   = shortest.source;

utils/hammingdistance.h

@@ -151,7 +151,7 @@ inline size_t conventionalHammingDistance(char unknown,
 inline uint64_t conventionalCountBitsSetInEither(uint64_t* a, uint64_t* b,
                                                size_t count /*in uint64_t*/) {
     uint64_t bits_set = 1;
-    for (int i=0; i<count; ++i) {
+    for (size_t i=0; i<count; ++i) {
         uint64_t bitsInEither = a[i] | b[i];
         uint64_t delta;
         #if (defined (__GNUC__) || defined(__clang__)) && !defined(CLANG_UNDER_VS)
@@ -175,7 +175,7 @@ inline uint64_t countBitsSetInEither(uint64_t* a, uint64_t* b, size_t count) {
 #else
 
 #ifdef _MSC_VER
-    #define ALIGN_32(x) __declspec(align(32)) x
+    #define ALIGN_32(x) __declspec(align(32)) x = {0}
 #else
     #define ALIGN_32(x) x __attribute__((aligned(32)))
 #endif
@@ -194,12 +194,12 @@ inline uint64_t vectorHammingDistanceTemplate(char unknown,
     DV       distance_vector  = 0;
     if (W <= seqLen) {
         blockStop  = seqLen - (seqLen & (W-1));
-        CV blockA; //next 32 bytes from a
-        CV blockB; //next 32 bytes from b
+        CV blockA(0); //next 32 bytes from a
+        CV blockB(0); //next 32 bytes from b
         CV blockU  = unknown;
         ALIGN_32(uint64_t vec[W/8]);
         ALIGN_32(uint64_t res[W/8]);
-        DV distance_bump_vector;
+        DV distance_bump_vector(0);
         for ( size_t i=0; i<blockStop; i+=W) {
 
             //Compare W characters at a time
@@ -248,11 +248,11 @@ uint64_t countBitsSetInEitherTemplate(uint64_t* a, uint64_t* b,
                                     size_t count /*in uint64_t*/) {
     //Assumes: W divides count
     V count_vector  = 0;
-    V aData;
-    V bData;
+    V aData = 0;
+    V bData = 0;
     ALIGN_32(uint64_t vec[W]);
     ALIGN_32(uint64_t res[W]);
-    V dData;
+    V dData = 0;
     for (int i=0; i<count; i+=W) {
         aData.load(a+i);
         bData.load(b+i);
@@ -309,7 +309,8 @@ inline size_t sumForUnknownCharacters
     int pos = 0;
     if (blockSize < seqLen) {
         //Next line assumes that: blockSize is power of 2
-        intptr_t blockStop = seqLen - (seqLen & (blockSize - 1)); 
+        int blockSize_less_1 = blockSize - 1;
+        intptr_t blockStop = seqLen - (seqLen & (blockSize_less_1)); 
         for (; pos < blockStop; pos += blockSize) {
             Vec32c blockRead;
             blockRead.load(sequence + pos);