Use size_t more

Author: michalsta

IsoSpec++/misc.cpp

@@ -25,17 +25,17 @@
 namespace IsoSpec
 {
 
-void* quickselect(void ** array, int n, int start, int end)
+void* quickselect(void ** array, size_t n, size_t start, size_t end)
 {
     if(start == end)
         return array[start];
 
     while(true)
     {
         // Partition part
-        int len = end - start;
+        size_t len = end - start;
 #if ISOSPEC_BUILDING_R
-        int pivot = len/2 + start;
+        size_t pivot = len/2 + start;
 #else
         size_t pivot = random_gen() % len + start;  // Using Mersenne twister directly - we don't
                                                     // need a very uniform distribution just for pivot
@@ -44,8 +44,8 @@ void* quickselect(void ** array, int n, int start, int end)
         void* pval = array[pivot];
         double pprob = getLProb(pval);
         std::swap(array[pivot], array[end-1]);
-        int loweridx = start;
-        for(int i = start; i < end-1; i++)
+        size_t loweridx = start;
+        for(size_t i = start; i < end-1; i++)
         {
             if(getLProb(array[i]) < pprob)
             {

IsoSpec++/misc.h

@@ -82,11 +82,11 @@ inline double calc_mass(const int* conf, const double* masses, int dim)
 
 
 
-template<typename T> void printArray(const T* array, int size, const char* prefix = "")
+template<typename T> void printArray(const T* array, size_t size, const char* prefix = "")
 {
     if (strlen(prefix) > 0)
         std::cout << prefix << " ";
-    for (int i = 0; i < size; i++)
+    for (size_t i = 0; i < size; i++)
         std::cout << array[i] << " ";
     std::cout << std::endl;
 }
@@ -101,34 +101,34 @@ template<typename T> void printVector(const pod_vector<T>& vec)
     printArray<T>(vec.data(), vec.size());
 }
 
-template<typename T> void printOffsets(const T** array, int size, const T* offset, const char* prefix = "")
+template<typename T> void printOffsets(const T** array, size_t size, const T* offset, const char* prefix = "")
 {
     if (strlen(prefix) > 0)
         std::cout << prefix << " ";
-    for (int i = 0; i < size; i++)
+    for (size_t i = 0; i < size; i++)
         std::cout << array[i] - offset << " ";
     std::cout << std::endl;
 }
 
-template<typename T> void printNestedArray(const T** array, const int* shape, int size)
+template<typename T> void printNestedArray(const T** array, const int* shape, size_t size)
 {
-    for (int i = 0; i < size; i++)
+    for (size_t i = 0; i < size; i++)
         printArray(array[i], shape[i]);
     std::cout << std::endl;
 }
 
 //! Quickly select the n'th positional statistic, including the weights.
-void* quickselect(const void** array, int n, int start, int end);
+void* quickselect(const void** array, size_t n, size_t start, size_t end);
 
 
-template <typename T> inline static T* array_copy(const T* A, int size)
+template <typename T> inline static T* array_copy(const T* A, size_t size)
 {
     T* ret = new T[size];
     memcpy(ret, A, size*sizeof(T));
     return ret;
 }
 
-template <typename T> static T* array_copy_nptr(const T* A, int size)
+template <typename T> static T* array_copy_nptr(const T* A, size_t size)
 {
     if(A == nullptr)
         return nullptr;
@@ -159,7 +159,7 @@ template<typename T> size_t* get_order(T* order_array, size_t N)
     for(size_t ii = 0; ii < N; ii++)
         arr[ii] = ii;
 
-    std::sort(arr, arr + N, [&](int i, int j) { return order_array[i] < order_array[j]; });
+    std::sort(arr, arr + N, [&](size_t i, size_t j) { return order_array[i] < order_array[j]; });
 
     return arr;
 }
@@ -170,7 +170,7 @@ template<typename T> size_t* get_inverse_order(T* order_array, size_t N)
     for(size_t ii = 0; ii < N; ii++)
         arr[ii] = ii;
 
-    std::sort(arr, arr + N, [&](int i, int j) { return order_array[i] > order_array[j]; });
+    std::sort(arr, arr + N, [&](size_t i, size_t j) { return order_array[i] > order_array[j]; });
 
     return arr;
 }

IsoSpec++/operators.h

@@ -126,7 +126,7 @@ template<typename T> class TableOrder
         const T* tbl;
  public:
         inline explicit TableOrder(const T* _tbl) : tbl(_tbl) {}
-        inline bool operator()(unsigned int i, unsigned int j) { return tbl[i] < tbl[j]; }
+        inline bool operator()(size_t i, size_t j) { return tbl[i] < tbl[j]; }
 };
 
 }  // namespace IsoSpec
@@ -143,7 +143,7 @@ template<typename T> class OrderMarginalsBySizeDecresing
     T const* const* const MT;
  public:
     explicit OrderMarginalsBySizeDecresing(T const* const * const MT_) : MT(MT_) {};
-    inline bool operator()(int m1, int m2) { return MT[m1]->get_no_confs() > MT[m2]->get_no_confs(); }
+    inline bool operator()(size_t m1, size_t m2) { return MT[m1]->get_no_confs() > MT[m2]->get_no_confs(); }
 };