Address some common compiler warnings.

This implements some clean-ups that address some compiler warnings.
Principal among these are more consistent uses of size_t for values
which are related to the sizes of containers.

Along the way, where it was straightforward to do so, some passages
were re-written to avoid signed/un-signed comparisons by using
instead STL algorithms and idioms.

Author: tturocy

src/core/function.cc

@@ -46,7 +46,7 @@ using namespace Gambit;
 void FunctionOnSimplices::Project(Vector<double> &x, const Array<int> &lengths) const
 {
   int index = 1;
-  for (int part = 1; part <= lengths.size(); part++) {
+  for (size_t part = 1; part <= lengths.size(); part++) {
     double avg = 0.0;
     int j;
     for (j = 1; j <= lengths[part]; j++, index++) {
@@ -70,7 +70,7 @@ void FunctionOnSimplices::Project(Vector<double> &x, const Array<int> &lengths)
 
 void ConjugatePRMinimizer::AlphaXPlusY(double alpha, const Vector<double> &x, Vector<double> &y)
 {
-  for (int i = 1; i <= y.size(); i++) {
+  for (size_t i = 1; i <= y.size(); i++) {
     y[i] += alpha * x[i];
   }
 }

src/core/matrix.h

@@ -80,14 +80,10 @@ template <class T> class Matrix : public RectArray<T> {
   Matrix<T> operator*(const Matrix<T> &) const;
   Vector<T> operator*(const Vector<T> &) const;
   Matrix<T> operator*(const T &) const;
-  Matrix<T> &operator*=(const Matrix<T> &);
   Matrix<T> &operator*=(const T &);
 
   Matrix<T> operator/(const T &) const;
   Matrix<T> &operator/=(const T &);
-
-  /// Kronecker product
-  Matrix<T> operator&(const Matrix<T> &) const;
   //@
 
   /// @name Other operations

src/core/matrix.imp

@@ -253,26 +253,6 @@ template <class T> Matrix<T> Matrix<T>::operator*(const T &s) const
   return tmp;
 }
 
-// in-place multiplication by square matrix
-template <class T> Matrix<T> &Matrix<T>::operator*=(const Matrix<T> &M)
-{
-  if (this->mincol != M.minrow || this->maxcol != M.maxrow) {
-    throw DimensionException();
-  }
-  if (M.minrow != M.mincol || M.maxrow != M.maxcol) {
-    throw DimensionException();
-  }
-
-  Vector<T> row(this->mincol, this->maxcol);
-  Vector<T> result(this->mincol, this->maxcol);
-  for (int i = this->minrow; i <= this->maxrow; i++) {
-    this->GetRow(i, row);
-    M.RMultiply(row, result);
-    this->SetRow(i, result);
-  }
-  return (*this);
-}
-
 template <class T> Matrix<T> &Matrix<T>::operator*=(const T &s)
 {
   for (int i = this->minrow; i <= this->maxrow; i++) {
@@ -281,7 +261,6 @@ template <class T> Matrix<T> &Matrix<T>::operator*=(const T &s)
     while (j--) {
       *(dst++) *= s;
     }
-    // assert((dst - 1) == this->data[i] + this->maxcol);
   }
   return (*this);
 }
@@ -300,7 +279,6 @@ template <class T> Matrix<T> Matrix<T>::operator/(const T &s) const
     while (j--) {
       *(dst++) = *(src++) / s;
     }
-    // assert((src - 1) == this->data[i] + this->maxcol);
   }
   return tmp;
 }
@@ -317,35 +295,10 @@ template <class T> Matrix<T> &Matrix<T>::operator/=(const T &s)
     while (j--) {
       *(dst++) /= s;
     }
-    // assert((dst - 1) == this->data[i] + this->maxcol);
   }
   return (*this);
 }
 
-//-------------------------------------------------------------------------
-//                  Matrix<T>: Kronecker Product
-//-------------------------------------------------------------------------
-
-template <class T> Matrix<T> Matrix<T>::operator&(const Matrix<T> &M) const
-{
-  Matrix<T> tmp(1, (this->maxrow - this->minrow + 1) * (M.maxrow - M.minrow + 1), 1,
-                (this->maxcol - this->mincol + 1) * (M.maxcol - M.mincol + 1));
-
-  for (int i = 0; i <= this->maxrow - this->minrow; i++) {
-    for (int j = 1; j <= M.maxrow - M.minrow + 1; j++) {
-      for (int k = 0; k <= this->maxcol - this->mincol; k++) {
-        for (int l = 1; l <= M.maxcol - M.mincol + 1; l++) {
-
-          tmp((M.maxrow - M.minrow + 1) * i + j, (M.maxcol - M.mincol + 1) * k + l) =
-              (*this)(i + this->minrow, k + this->mincol) * M(j + M.minrow - 1, l + M.mincol - 1);
-        }
-      }
-    }
-  }
-
-  return tmp;
-}
-
 //-------------------------------------------------------------------------
 //                         Matrix<T>: Transpose
 //-------------------------------------------------------------------------