--- a/liboctave/dMatrix.cc
+++ b/liboctave/dMatrix.cc
@@ -1356,16 +1356,18 @@
 
   double *p_m = m.fortran_vec ();
 
-  int info, ilo, ihi,ilos,ihis, ii, jj;
-  Array<double> dpermute(nc);
-  Array<double> dscale(nc);
+  int info, ilo, ihi, ilos, ihis;
+  Array<double> dpermute (nc);
+  Array<double> dscale (nc);
   double *dp;
 
-  char job = 'P';       // permutation first
+  // permutation first
+  char job = 'P';
   dp = dpermute.fortran_vec();
   F77_XFCN (dgebal, DGEBAL, (&job, nc, p_m, nc, ilo, ihi, dp, info, 1L, 1L));
 
-  job = 'S';       // then scaling
+  // then scaling
+  job = 'S';
   dp = dscale.fortran_vec();
   F77_XFCN (dgebal, DGEBAL, (&job, nc, p_m, nc, ilos, ihis, dp, info, 1L, 1L));
 
@@ -1445,41 +1447,42 @@
   
   // Reverse preconditioning step 2: inverse balancing.
   // apply inverse scaling to computed exponential
-  for(ii = 0; ii < nc ; ii++)
-    for(jj=0; jj < nc ; jj++)
-       retval(ii,jj) *= dscale(ii)/dscale(jj);
+  for (int i = 0; i < nc; i++)
+    for (int j = 0; j < nc; j++)
+       retval(i,j) *= dscale(i) / dscale(j);
 
   // construct balancing permutation vector
-  Array<int> ipermute(nc);
-  for(ii=0 ; ii < nc ; ii++) ipermute(ii) = ii;  // identity permutation
+  Array<int> ipermute (nc);
+  for (int i = 0; i < nc; i++)
+    ipermute(i) = i;  // identity permutation
 
   // leading permutations in forward order
-  for( ii = 0 ; ii < (ilo-1) ; ii++)
-  {
-    int swapidx = ( (int) dpermute(ii) ) -1;
-    int tmp = ipermute(ii);
-    ipermute(ii) = ipermute( swapidx );
-    ipermute(swapidx) = tmp;
-  }
+  for (int i = 0; i < (ilo-1); i++)
+    {
+      int swapidx = static_cast<int> (dpermute(i)) - 1;
+      int tmp = ipermute(i);
+      ipermute(i) = ipermute (swapidx);
+      ipermute(swapidx) = tmp;
+    }
 
   // trailing permutations must be done in reverse order
-  for( ii = nc-1 ; ii >= ihi ; ii--)
-  {
-    int swapidx = ( (int) dpermute(ii) ) -1;
-    int tmp = ipermute(ii);
-    ipermute(ii) = ipermute( swapidx );
-    ipermute(swapidx) = tmp;
-  }
+  for (int i = nc - 1; i >= ihi; i--)
+    {
+      int swapidx = static_cast<int> (dpermute(i)) - 1;
+      int tmp = ipermute(i);
+      ipermute(i) = ipermute(swapidx);
+      ipermute(swapidx) = tmp;
+    }
 
   // construct inverse balancing permutation vector
-  Array<int> invpvec(nc);
-  for( ii = 0 ; ii < nc ; ii++)
-    invpvec(ipermute(ii)) = ii ;     // Thanks to R. A. Lippert for this method
+  Array<int> invpvec (nc);
+  for (int i = 0; i < nc; i++)
+    invpvec(ipermute(i)) = i;     // Thanks to R. A. Lippert for this method
  
   Matrix tmpMat = retval;
-  for( ii = 0 ; ii < nc ; ii ++)
-    for( jj= 0 ; jj < nc ; jj++ )
-      retval(ii,jj) = tmpMat(invpvec(ii),invpvec(jj));
+  for (int i = 0; i < nc; i++)
+    for (int j = 0; j < nc; j++)
+      retval(i,j) = tmpMat(invpvec(i),invpvec(j));
 
   // Reverse preconditioning step 1: fix trace normalization.