--- a/liboctave/array/Array-C.cc	Sat Oct 26 23:20:30 2013 +0200
+++ b/liboctave/array/Array-C.cc	Sat Oct 26 18:57:05 2013 -0700
@@ -92,7 +92,8 @@
 
 INSTANTIATE_ARRAY (Complex, OCTAVE_API);
 
-template OCTAVE_API std::ostream& operator << (std::ostream&, const Array<Complex>&);
+template OCTAVE_API std::ostream& operator << (std::ostream&,
+                                               const Array<Complex>&);
 
 #include "DiagArray2.h"
 #include "DiagArray2.cc"

--- a/liboctave/array/Array-b.cc	Sat Oct 26 23:20:30 2013 +0200
+++ b/liboctave/array/Array-b.cc	Sat Oct 26 18:57:05 2013 -0700
@@ -107,7 +107,8 @@
 
 INSTANTIATE_ARRAY (bool, OCTAVE_API);
 
-template OCTAVE_API std::ostream& operator << (std::ostream&, const Array<bool>&);
+template OCTAVE_API std::ostream& operator << (std::ostream&,
+                                               const Array<bool>&);
 
 #include "DiagArray2.h"
 #include "DiagArray2.cc"

--- a/liboctave/array/Array-ch.cc	Sat Oct 26 23:20:30 2013 +0200
+++ b/liboctave/array/Array-ch.cc	Sat Oct 26 18:57:05 2013 -0700
@@ -36,7 +36,8 @@
 
 INSTANTIATE_ARRAY (char, OCTAVE_API);
 
-template OCTAVE_API std::ostream& operator << (std::ostream&, const Array<char>&);
+template OCTAVE_API std::ostream& operator << (std::ostream&,
+                                               const Array<char>&);
 
 #include "DiagArray2.h"
 #include "DiagArray2.cc"

--- a/liboctave/array/Array-d.cc	Sat Oct 26 23:20:30 2013 +0200
+++ b/liboctave/array/Array-d.cc	Sat Oct 26 18:57:05 2013 -0700
@@ -159,7 +159,8 @@
 
 INSTANTIATE_ARRAY (double, OCTAVE_API);
 
-template OCTAVE_API std::ostream& operator << (std::ostream&, const Array<double>&);
+template OCTAVE_API std::ostream& operator << (std::ostream&,
+                                               const Array<double>&);
 
 #include "DiagArray2.h"
 #include "DiagArray2.cc"

--- a/liboctave/array/Array-f.cc	Sat Oct 26 23:20:30 2013 +0200
+++ b/liboctave/array/Array-f.cc	Sat Oct 26 18:57:05 2013 -0700
@@ -159,7 +159,8 @@
 
 INSTANTIATE_ARRAY (float, OCTAVE_API);
 
-template OCTAVE_API std::ostream& operator << (std::ostream&, const Array<float>&);
+template OCTAVE_API std::ostream& operator << (std::ostream&,
+                                               const Array<float>&);
 
 #include "DiagArray2.h"
 #include "DiagArray2.cc"

--- a/liboctave/array/Array-fC.cc	Sat Oct 26 23:20:30 2013 +0200
+++ b/liboctave/array/Array-fC.cc	Sat Oct 26 18:57:05 2013 -0700
@@ -60,8 +60,7 @@
 }
 
 Array<FloatComplex>::compare_fcn_type
-safe_comparator (sortmode mode, const Array<FloatComplex>& a,
-                     bool allow_chk)
+safe_comparator (sortmode mode, const Array<FloatComplex>& a, bool allow_chk)
 {
   Array<FloatComplex>::compare_fcn_type result = 0;
 
@@ -93,7 +92,8 @@
 
 INSTANTIATE_ARRAY (FloatComplex, OCTAVE_API);
 
-template OCTAVE_API std::ostream& operator << (std::ostream&, const Array<FloatComplex>&);
+template OCTAVE_API std::ostream& operator << (std::ostream&,
+                                               const Array<FloatComplex>&);
 
 #include "DiagArray2.h"
 #include "DiagArray2.cc"

--- a/liboctave/array/Array-util.cc	Sat Oct 26 23:20:30 2013 +0200
+++ b/liboctave/array/Array-util.cc	Sat Oct 26 18:57:05 2013 -0700
@@ -247,7 +247,7 @@
   Array<idx_vector> retval (dim_vector (len, 1));
 
   for (octave_idx_type i = 0; i < len; i++)
-      retval(i) = tmp[i];
+    retval(i) = tmp[i];
 
   return retval;
 }
@@ -403,8 +403,7 @@
   for (octave_idx_type i = 0; i < idx; i++)
     increment_index (retval, dims);
 
-  // FIXME -- the solution using increment_index is not
-  // efficient.
+  // FIXME: the solution using increment_index is not efficient.
 
 #if 0
   octave_idx_type var = 1;
@@ -432,7 +431,7 @@
   bool all_colons = true;
   for (int i = 0; i < ial; i++)
     {
-      // FIXME -- should we check for length() instead?
+      // FIXME: should we check for length() instead?
       scalar[i] = ia(i).is_scalar ();
       colon[i] = ia(i).is_colon ();
       if (! scalar[i]) nonsc++;

--- a/liboctave/array/Array-util.h	Sat Oct 26 23:20:30 2013 +0200
+++ b/liboctave/array/Array-util.h	Sat Oct 26 18:57:05 2013 -0700
@@ -29,15 +29,17 @@
 #include "lo-array-gripes.h"
 
 extern OCTAVE_API bool index_in_bounds (const Array<octave_idx_type>& ra_idx,
-                             const dim_vector& dimensions);
+                                        const dim_vector& dimensions);
 
 extern OCTAVE_API void increment_index (Array<octave_idx_type>& ra_idx,
-                             const dim_vector& dimensions,
-                             int start_dimension = 0);
+                                        const dim_vector& dimensions,
+                                        int start_dimension = 0);
 
-extern OCTAVE_API octave_idx_type get_scalar_idx (Array<octave_idx_type>& idx, dim_vector& dims);
+extern OCTAVE_API octave_idx_type get_scalar_idx (Array<octave_idx_type>& idx,
+                                                  dim_vector& dims);
 
-extern OCTAVE_API octave_idx_type num_ones (const Array<octave_idx_type>& ra_idx);
+extern OCTAVE_API octave_idx_type num_ones (const Array<octave_idx_type>&
+                                            ra_idx);
 
 extern OCTAVE_API bool is_scalar (const dim_vector& dim);
 
@@ -60,12 +62,15 @@
 extern OCTAVE_API octave_idx_type
 compute_index (const Array<octave_idx_type>& ra_idx, const dim_vector& dims);
 
-extern OCTAVE_API Array<octave_idx_type> conv_to_int_array (const Array<idx_vector>& a);
+extern OCTAVE_API Array<octave_idx_type>
+conv_to_int_array (const Array<idx_vector>& a);
 
-extern OCTAVE_API Array<idx_vector> conv_to_array (const idx_vector *tmp, const octave_idx_type len);
+extern OCTAVE_API Array<idx_vector> conv_to_array (const idx_vector *tmp,
+                                                   const octave_idx_type len);
 
 extern OCTAVE_API dim_vector freeze (Array<idx_vector>& ra_idx,
-                          const dim_vector& dimensions, int resize_ok);
+                                     const dim_vector& dimensions,
+                                     int resize_ok);
 
 extern OCTAVE_API bool vector_equivalent (const dim_vector& dv);
 
@@ -74,24 +79,29 @@
 extern OCTAVE_API bool any_orig_empty (const Array<idx_vector>& ra_idx);
 
 extern OCTAVE_API bool all_colon_equiv (const Array<idx_vector>& ra_idx,
-                             const dim_vector& frozen_lengths);
+                                        const dim_vector& frozen_lengths);
 
 extern OCTAVE_API bool all_ones (const Array<octave_idx_type>& arr);
 
-extern OCTAVE_API Array<octave_idx_type> get_elt_idx (const Array<idx_vector>& ra_idx,
-                               const Array<octave_idx_type>& result_idx);
+extern OCTAVE_API Array<octave_idx_type>
+get_elt_idx (const Array<idx_vector>& ra_idx,
+             const Array<octave_idx_type>& result_idx);
 
-extern OCTAVE_API Array<octave_idx_type> get_ra_idx (octave_idx_type idx, const dim_vector& dims);
+extern OCTAVE_API Array<octave_idx_type> get_ra_idx (octave_idx_type idx,
+                                                     const dim_vector& dims);
 
 extern OCTAVE_API dim_vector zero_dims_inquire (const Array<idx_vector>& ia,
                                                 const dim_vector& rhdv);
 
-extern OCTAVE_API dim_vector zero_dims_inquire (const idx_vector& i, const idx_vector& j,
+extern OCTAVE_API dim_vector zero_dims_inquire (const idx_vector& i,
+                                                const idx_vector& j,
                                                 const dim_vector& rhdv);
 
-extern OCTAVE_API idx_vector sub2ind (const dim_vector& dv, const Array<idx_vector>& idxa);
+extern OCTAVE_API idx_vector sub2ind (const dim_vector& dv,
+                                      const Array<idx_vector>& idxa);
 
-extern OCTAVE_API Array<idx_vector> ind2sub (const dim_vector& dv, const idx_vector& idx);
+extern OCTAVE_API Array<idx_vector> ind2sub (const dim_vector& dv,
+                                             const idx_vector& idx);
 
 struct
 permute_vector

--- a/liboctave/array/Array.cc	Sat Oct 26 23:20:30 2013 +0200
+++ b/liboctave/array/Array.cc	Sat Oct 26 18:57:05 2013 -0700
@@ -171,7 +171,8 @@
 
 template <class T>
 octave_idx_type
-Array<T>::compute_index (octave_idx_type i, octave_idx_type j, octave_idx_type k) const
+Array<T>::compute_index (octave_idx_type i, octave_idx_type j,
+                         octave_idx_type k) const
 {
   return ::compute_index (i, j, k, dimensions);
 }
@@ -239,7 +240,8 @@
 
 template <class T>
 typename Array<T>::crefT
-Array<T>::checkelem (octave_idx_type i, octave_idx_type j, octave_idx_type k) const
+Array<T>::checkelem (octave_idx_type i, octave_idx_type j,
+                     octave_idx_type k) const
 {
   return elem (compute_index (i, j, k));
 }
@@ -308,39 +310,39 @@
 
     : n (dv.length ()), top (0), dim (new octave_idx_type [2*n]),
       stride (dim + n), use_blk (false)
-    {
-      assert (n == perm.length ());
-
-      // Get cumulative dimensions.
-      OCTAVE_LOCAL_BUFFER (octave_idx_type, cdim, n+1);
-      cdim[0] = 1;
-      for (int i = 1; i < n+1; i++) cdim[i] = cdim[i-1] * dv(i-1);
-
-      // Setup the permuted strides.
-      for (int k = 0; k < n; k++)
-        {
-          int kk = perm(k);
-          dim[k] = dv(kk);
-          stride[k] = cdim[kk];
-        }
-
-      // Reduce contiguous runs.
-      for (int k = 1; k < n; k++)
-        {
-          if (stride[k] == stride[top]*dim[top])
-            dim[top] *= dim[k];
-          else
-            {
-              top++;
-              dim[top] = dim[k];
-              stride[top] = stride[k];
-            }
-        }
-
-      // Determine whether we can use block transposes.
-      use_blk = top >= 1 && stride[1] == 1 && stride[0] == dim[1];
-
-    }
+  {
+    assert (n == perm.length ());
+
+    // Get cumulative dimensions.
+    OCTAVE_LOCAL_BUFFER (octave_idx_type, cdim, n+1);
+    cdim[0] = 1;
+    for (int i = 1; i < n+1; i++) cdim[i] = cdim[i-1] * dv(i-1);
+
+    // Setup the permuted strides.
+    for (int k = 0; k < n; k++)
+      {
+        int kk = perm(k);
+        dim[k] = dv(kk);
+        stride[k] = cdim[kk];
+      }
+
+    // Reduce contiguous runs.
+    for (int k = 1; k < n; k++)
+      {
+        if (stride[k] == stride[top]*dim[top])
+          dim[top] *= dim[k];
+        else
+          {
+            top++;
+            dim[top] = dim[k];
+            stride[top] = stride[k];
+          }
+      }
+
+    // Determine whether we can use block transposes.
+    use_blk = top >= 1 && stride[1] == 1 && stride[0] == dim[1];
+
+  }
 
   ~rec_permute_helper (void) { delete [] dim; }
 
@@ -348,74 +350,74 @@
   template <class T>
   static T *
   blk_trans (const T *src, T *dest, octave_idx_type nr, octave_idx_type nc)
-    {
-      static const octave_idx_type m = 8;
-      OCTAVE_LOCAL_BUFFER (T, blk, m*m);
-      for (octave_idx_type kr = 0; kr < nr; kr += m)
-        for (octave_idx_type kc = 0; kc < nc; kc += m)
-          {
-            octave_idx_type lr = std::min (m, nr - kr);
-            octave_idx_type lc = std::min (m, nc - kc);
-            if (lr == m && lc == m)
-              {
-                const T *ss = src + kc * nr + kr;
-                for (octave_idx_type j = 0; j < m; j++)
-                  for (octave_idx_type i = 0; i < m; i++)
-                    blk[j*m+i] = ss[j*nr + i];
-                T *dd = dest + kr * nc + kc;
-                for (octave_idx_type j = 0; j < m; j++)
-                  for (octave_idx_type i = 0; i < m; i++)
-                    dd[j*nc+i] = blk[i*m+j];
-              }
-            else
-              {
-                const T *ss = src + kc * nr + kr;
-                for (octave_idx_type j = 0; j < lc; j++)
-                  for (octave_idx_type i = 0; i < lr; i++)
-                    blk[j*m+i] = ss[j*nr + i];
-                T *dd = dest + kr * nc + kc;
-                for (octave_idx_type j = 0; j < lr; j++)
-                  for (octave_idx_type i = 0; i < lc; i++)
-                    dd[j*nc+i] = blk[i*m+j];
-              }
-          }
-
-      return dest + nr*nc;
-    }
+  {
+    static const octave_idx_type m = 8;
+    OCTAVE_LOCAL_BUFFER (T, blk, m*m);
+    for (octave_idx_type kr = 0; kr < nr; kr += m)
+      for (octave_idx_type kc = 0; kc < nc; kc += m)
+        {
+          octave_idx_type lr = std::min (m, nr - kr);
+          octave_idx_type lc = std::min (m, nc - kc);
+          if (lr == m && lc == m)
+            {
+              const T *ss = src + kc * nr + kr;
+              for (octave_idx_type j = 0; j < m; j++)
+                for (octave_idx_type i = 0; i < m; i++)
+                  blk[j*m+i] = ss[j*nr + i];
+              T *dd = dest + kr * nc + kc;
+              for (octave_idx_type j = 0; j < m; j++)
+                for (octave_idx_type i = 0; i < m; i++)
+                  dd[j*nc+i] = blk[i*m+j];
+            }
+          else
+            {
+              const T *ss = src + kc * nr + kr;
+              for (octave_idx_type j = 0; j < lc; j++)
+                for (octave_idx_type i = 0; i < lr; i++)
+                  blk[j*m+i] = ss[j*nr + i];
+              T *dd = dest + kr * nc + kc;
+              for (octave_idx_type j = 0; j < lr; j++)
+                for (octave_idx_type i = 0; i < lc; i++)
+                  dd[j*nc+i] = blk[i*m+j];
+            }
+        }
+
+    return dest + nr*nc;
+  }
 
 private:
 
   // Recursive N-d generalized transpose
   template <class T>
   T *do_permute (const T *src, T *dest, int lev) const
-    {
-      if (lev == 0)
-        {
-          octave_idx_type step = stride[0], len = dim[0];
-          if (step == 1)
-            {
-              copy_or_memcpy (len, src, dest);
-              dest += len;
-            }
-          else
-            {
-              for (octave_idx_type i = 0, j = 0; i < len; i++, j += step)
-                dest[i] = src[j];
-
-              dest += len;
-            }
-        }
-      else if (use_blk && lev == 1)
-        dest = blk_trans (src, dest, dim[1], dim[0]);
-      else
-        {
-          octave_idx_type step = stride[lev], len = dim[lev];
-          for (octave_idx_type i = 0, j = 0; i < len; i++, j+= step)
-           dest = do_permute (src + i * step, dest, lev-1);
-        }
-
-      return dest;
-    }
+  {
+    if (lev == 0)
+      {
+        octave_idx_type step = stride[0], len = dim[0];
+        if (step == 1)
+          {
+            copy_or_memcpy (len, src, dest);
+            dest += len;
+          }
+        else
+          {
+            for (octave_idx_type i = 0, j = 0; i < len; i++, j += step)
+              dest[i] = src[j];
+
+            dest += len;
+          }
+      }
+    else if (use_blk && lev == 1)
+      dest = blk_trans (src, dest, dim[1], dim[0]);
+    else
+      {
+        octave_idx_type step = stride[lev], len = dim[lev];
+        for (octave_idx_type i = 0, j = 0; i < len; i++, j+= step)
+          dest = do_permute (src + i * step, dest, lev-1);
+      }
+
+    return dest;
+  }
 
   // No copying!
 
@@ -528,31 +530,31 @@
   rec_index_helper (const dim_vector& dv, const Array<idx_vector>& ia)
     : n (ia.length ()), top (0), dim (new octave_idx_type [2*n]),
       cdim (dim + n), idx (new idx_vector [n])
-    {
-      assert (n > 0 && (dv.length () == std::max (n, 2)));
-
-      dim[0] = dv(0);
-      cdim[0] = 1;
-      idx[0] = ia(0);
-
-      for (int i = 1; i < n; i++)
-        {
-          // Try reduction...
-          if (idx[top].maybe_reduce (dim[top], ia(i), dv(i)))
-            {
-              // Reduction successful, fold dimensions.
-              dim[top] *= dv(i);
-            }
-          else
-            {
-              // Unsuccessful, store index & cumulative dim.
-              top++;
-              idx[top] = ia(i);
-              dim[top] = dv(i);
-              cdim[top] = cdim[top-1] * dim[top-1];
-            }
-        }
-    }
+  {
+    assert (n > 0 && (dv.length () == std::max (n, 2)));
+
+    dim[0] = dv(0);
+    cdim[0] = 1;
+    idx[0] = ia(0);
+
+    for (int i = 1; i < n; i++)
+      {
+        // Try reduction...
+        if (idx[top].maybe_reduce (dim[top], ia(i), dv(i)))
+          {
+            // Reduction successful, fold dimensions.
+            dim[top] *= dv(i);
+          }
+        else
+          {
+            // Unsuccessful, store index & cumulative dim.
+            top++;
+            idx[top] = ia(i);
+            dim[top] = dv(i);
+            cdim[top] = cdim[top-1] * dim[top-1];
+          }
+      }
+  }
 
   ~rec_index_helper (void) { delete [] idx; delete [] dim; }
 
@@ -561,48 +563,48 @@
   // Recursive N-d indexing
   template <class T>
   T *do_index (const T *src, T *dest, int lev) const
-    {
-      if (lev == 0)
-        dest += idx[0].index (src, dim[0], dest);
-      else
-        {
-          octave_idx_type nn = idx[lev].length (dim[lev]), d = cdim[lev];
-          for (octave_idx_type i = 0; i < nn; i++)
-            dest = do_index (src + d*idx[lev].xelem (i), dest, lev-1);
-        }
-
-      return dest;
-    }
+  {
+    if (lev == 0)
+      dest += idx[0].index (src, dim[0], dest);
+    else
+      {
+        octave_idx_type nn = idx[lev].length (dim[lev]), d = cdim[lev];
+        for (octave_idx_type i = 0; i < nn; i++)
+          dest = do_index (src + d*idx[lev].xelem (i), dest, lev-1);
+      }
+
+    return dest;
+  }
 
   // Recursive N-d indexed assignment
   template <class T>
   const T *do_assign (const T *src, T *dest, int lev) const
-    {
-      if (lev == 0)
-        src += idx[0].assign (src, dim[0], dest);
-      else
-        {
-          octave_idx_type nn = idx[lev].length (dim[lev]), d = cdim[lev];
-          for (octave_idx_type i = 0; i < nn; i++)
-            src = do_assign (src, dest + d*idx[lev].xelem (i), lev-1);
-        }
-
-      return src;
-    }
+  {
+    if (lev == 0)
+      src += idx[0].assign (src, dim[0], dest);
+    else
+      {
+        octave_idx_type nn = idx[lev].length (dim[lev]), d = cdim[lev];
+        for (octave_idx_type i = 0; i < nn; i++)
+          src = do_assign (src, dest + d*idx[lev].xelem (i), lev-1);
+      }
+
+    return src;
+  }
 
   // Recursive N-d indexed assignment
   template <class T>
   void do_fill (const T& val, T *dest, int lev) const
-    {
-      if (lev == 0)
-        idx[0].fill (val, dim[0], dest);
-      else
-        {
-          octave_idx_type nn = idx[lev].length (dim[lev]), d = cdim[lev];
-          for (octave_idx_type i = 0; i < nn; i++)
-            do_fill (val, dest + d*idx[lev].xelem (i), lev-1);
-        }
-    }
+  {
+    if (lev == 0)
+      idx[0].fill (val, dim[0], dest);
+    else
+      {
+        octave_idx_type nn = idx[lev].length (dim[lev]), d = cdim[lev];
+        for (octave_idx_type i = 0; i < nn; i++)
+          do_fill (val, dest + d*idx[lev].xelem (i), lev-1);
+      }
+  }
 
   // No copying!
 
@@ -622,10 +624,10 @@
   void fill (const T& val, T *dest) const { do_fill (val, dest, top); }
 
   bool is_cont_range (octave_idx_type& l,
-                            octave_idx_type& u) const
-    {
-      return top == 0 && idx[0].is_cont_range (dim[0], l, u);
-    }
+                      octave_idx_type& u) const
+  {
+    return top == 0 && idx[0].is_cont_range (dim[0], l, u);
+  }
 };
 
 // Helper class for multi-d recursive resizing
@@ -641,27 +643,27 @@
 public:
   rec_resize_helper (const dim_vector& ndv, const dim_vector& odv)
     : cext (0), sext (0), dext (0), n (0)
-    {
-      int l = ndv.length ();
-      assert (odv.length () == l);
-      octave_idx_type ld = 1;
-      int i = 0;
-      for (; i < l-1 && ndv(i) == odv(i); i++) ld *= ndv(i);
-      n = l - i;
-      cext = new octave_idx_type [3*n];
-      // Trick to avoid three allocations
-      sext = cext + n;
-      dext = sext + n;
-
-      octave_idx_type sld = ld, dld = ld;
-      for (int j = 0; j < n; j++)
-        {
-          cext[j] = std::min (ndv(i+j), odv(i+j));
-          sext[j] = sld *= odv(i+j);
-          dext[j] = dld *= ndv(i+j);
-        }
-      cext[0] *= ld;
-    }
+  {
+    int l = ndv.length ();
+    assert (odv.length () == l);
+    octave_idx_type ld = 1;
+    int i = 0;
+    for (; i < l-1 && ndv(i) == odv(i); i++) ld *= ndv(i);
+    n = l - i;
+    cext = new octave_idx_type [3*n];
+    // Trick to avoid three allocations
+    sext = cext + n;
+    dext = sext + n;
+
+    octave_idx_type sld = ld, dld = ld;
+    for (int j = 0; j < n; j++)
+      {
+        cext[j] = std::min (ndv(i+j), odv(i+j));
+        sext[j] = sld *= odv(i+j);
+        dext[j] = dld *= ndv(i+j);
+      }
+    cext[0] *= ld;
+  }
 
   ~rec_resize_helper (void) { delete [] cext; }
 
@@ -670,21 +672,21 @@
   // recursive resizing
   template <class T>
   void do_resize_fill (const T* src, T *dest, const T& rfv, int lev) const
-    {
-      if (lev == 0)
-        {
-          copy_or_memcpy (cext[0], src, dest);
-          fill_or_memset (dext[0] - cext[0], rfv, dest + cext[0]);
-        }
-      else
-        {
-          octave_idx_type sd = sext[lev-1], dd = dext[lev-1], k;
-          for (k = 0; k < cext[lev]; k++)
-            do_resize_fill (src + k * sd, dest + k * dd, rfv, lev - 1);
-
-          fill_or_memset (dext[lev] - k * dd, rfv, dest + k * dd);
-        }
-    }
+  {
+    if (lev == 0)
+      {
+        copy_or_memcpy (cext[0], src, dest);
+        fill_or_memset (dext[0] - cext[0], rfv, dest + cext[0]);
+      }
+    else
+      {
+        octave_idx_type sd = sext[lev-1], dd = dext[lev-1], k;
+        for (k = 0; k < cext[lev]; k++)
+          do_resize_fill (src + k * sd, dest + k * dd, rfv, lev - 1);
+
+        fill_or_memset (dext[lev] - k * dd, rfv, dest + k * dd);
+      }
+  }
 
   // No copying!
 
@@ -696,7 +698,7 @@
 
   template <class T>
   void resize_fill (const T* src, T *dest, const T& rfv) const
-    { do_resize_fill (src, dest, rfv, n-1); }
+  { do_resize_fill (src, dest, rfv, n-1); }
 };
 
 template <class T>
@@ -716,11 +718,11 @@
       if (i.extent (n) != n)
         gripe_index_out_of_range (1, 1, i.extent (n), n); // throws
 
-      // FIXME -- this is the only place where orig_dimensions are used.
+      // FIXME: this is the only place where orig_dimensions are used.
       dim_vector rd = i.orig_dimensions ();
       octave_idx_type il = i.length (n);
 
-      // FIXME -- this is for Matlab compatibility.  Matlab 2007 given
+      // FIXME: this is for Matlab compatibility.  Matlab 2007 given
       //
       //   b = ones (3,1)
       //
@@ -796,7 +798,7 @@
             retval = Array<T> (*this, dim_vector (il, jl), l, u);
           else
             {
-              // Don't use resize here to avoid useless initialization for POD types.
+              // Don't use resize to avoid useless initialization for POD types.
               retval = Array<T> (dim_vector (il, jl));
 
               ii.index (data (), n, retval.fortran_vec ());
@@ -804,7 +806,7 @@
         }
       else
         {
-          // Don't use resize here to avoid useless initialization for POD types.
+          // Don't use resize to avoid useless initialization for POD types.
           retval = Array<T> (dim_vector (il, jl));
 
           const T* src = data ();
@@ -868,7 +870,7 @@
             retval = Array<T> (*this, rdv, l, u);
           else
             {
-              // Don't use resize here to avoid useless initialization for POD types.
+              // Don't use resize to avoid useless initialization for POD types.
               retval = Array<T> (rdv);
 
               // Do it.
@@ -913,7 +915,7 @@
       else if (columns () == 1)
         dv = dim_vector (n, 1);
       else
-         invalid = true;
+        invalid = true;
 
       if (invalid)
         gripe_invalid_resize ();
@@ -931,7 +933,8 @@
           else if (n == nx + 1 && nx > 0)
             {
               // Stack "push" operation.
-              if (rep->count == 1 && slice_data + slice_len < rep->data + rep->len)
+              if (rep->count == 1
+                  && slice_data + slice_len < rep->data + rep->len)
                 {
                   slice_data[slice_len++] = rfv;
                   dimensions = dv;
@@ -2162,7 +2165,8 @@
 
   lsort.set_compare (mode);
 
-  // This determines the split ratio between the O(M*log2(N)) and O(M+N) algorithms.
+  // This determines the split ratio between the O(M*log2(N)) and O(M+N)
+  // algorithms.
   static const double ratio = 1.0;
   sortmode vmode = UNSORTED;
 
@@ -2232,7 +2236,7 @@
           octave_idx_type k = 0, l = nel - 1;
           for (; k < n; k++)
             {
-              for (;l >= 0 && src[l] == zero; l--) ;
+              for (; l >= 0 && src[l] == zero; l--) ;
               if (l >= 0)
                 retval(k) = l--;
               else
@@ -2249,7 +2253,7 @@
           octave_idx_type k = 0, l = 0;
           for (; k < n; k++)
             {
-              for (;l != nel && src[l] == zero; l++) ;
+              for (; l != nel && src[l] == zero; l++) ;
               if (l != nel)
                 retval(k) = l++;
               else
@@ -2401,7 +2405,7 @@
         }
 
       if (ku == ns)
-          lsort.nth_element (buf, ns, lo, up);
+        lsort.nth_element (buf, ns, lo, up);
       else if (mode == ASCENDING)
         lsort.nth_element (buf, ku, lo, std::min (ku, up));
       else
@@ -2477,7 +2481,7 @@
  \
 template <> Array<T>  \
 Array<T>::nth_element (const idx_vector&, int) const { return Array<T> (); } \
-
+ 
 
 template <class T>
 Array<T>

--- a/liboctave/array/Array.h	Sat Oct 26 23:20:30 2013 +0200
+++ b/liboctave/array/Array.h	Sat Oct 26 18:57:05 2013 -0700
@@ -64,32 +64,33 @@
 
     ArrayRep (T *d, octave_idx_type l)
       : data (no_ctor_new<T> (l)), len (l), count (1)
-        {
-          copy_or_memcpy (l, d, data);
-        }
+    {
+      copy_or_memcpy (l, d, data);
+    }
 
     template <class U>
     ArrayRep (U *d, octave_idx_type l)
       : data (no_ctor_new<T> (l)), len (l), count (1)
-        {
-          std::copy (d, d+l, data);
-        }
+    {
+      std::copy (d, d+l, data);
+    }
 
     ArrayRep (void) : data (0), len (0), count (1) { }
 
-    explicit ArrayRep (octave_idx_type n) : data (no_ctor_new<T> (n)), len (n), count (1) { }
+    explicit ArrayRep (octave_idx_type n)
+      : data (no_ctor_new<T> (n)), len (n), count (1) { }
 
     explicit ArrayRep (octave_idx_type n, const T& val)
       : data (no_ctor_new<T> (n)), len (n), count (1)
-      {
-        fill_or_memset (n, val, data);
-      }
+    {
+      fill_or_memset (n, val, data);
+    }
 
     ArrayRep (const ArrayRep& a)
       : data (no_ctor_new<T> (a.len)), len (a.len), count (1)
-      {
-        copy_or_memcpy (a.len, a.data, data);
-      }
+    {
+      copy_or_memcpy (a.len, a.data, data);
+    }
 
     ~ArrayRep (void) { no_ctor_delete<T> (data); }
 
@@ -107,18 +108,18 @@
 public:
 
   void make_unique (void)
-    {
-      if (rep->count > 1)
-        {
-          ArrayRep *r = new ArrayRep (slice_data, slice_len);
+  {
+    if (rep->count > 1)
+      {
+        ArrayRep *r = new ArrayRep (slice_data, slice_len);
 
-          if (--rep->count == 0)
-            delete rep;
-          
-          rep = r;
-          slice_data = rep->data;
-        }
-    }
+        if (--rep->count == 0)
+          delete rep;
+
+        rep = r;
+        slice_data = rep->data;
+      }
+  }
 
   typedef T element_type;
 
@@ -147,22 +148,22 @@
   Array (const Array<T>& a, const dim_vector& dv,
          octave_idx_type l, octave_idx_type u)
     : dimensions (dv), rep(a.rep), slice_data (a.slice_data+l), slice_len (u-l)
-    {
-      rep->count++;
-      dimensions.chop_trailing_singletons ();
-    }
+  {
+    rep->count++;
+    dimensions.chop_trailing_singletons ();
+  }
 
 private:
 
   typename Array<T>::ArrayRep *nil_rep (void) const
-    {
-      // NR was originally allocated with new, but that does not seem
-      // to be necessary since it will never be deleted.  So just use
-      // a static object instead.
+  {
+    // NR was originally allocated with new, but that does not seem
+    // to be necessary since it will never be deleted.  So just use
+    // a static object instead.
 
-      static typename Array<T>::ArrayRep nr;
-      return &nr;
-    }
+    static typename Array<T>::ArrayRep nr;
+    return &nr;
+  }
 
 protected:
 
@@ -170,7 +171,7 @@
   Array (T *sdata, octave_idx_type slen, octave_idx_type *adims, void *arep)
     : dimensions (adims),
       rep (reinterpret_cast<typename Array<T>::ArrayRep *> (arep)),
-      slice_data (sdata), slice_len (slen) {}
+      slice_data (sdata), slice_len (slen) { }
 
 public:
 
@@ -179,42 +180,42 @@
   Array (void)
     : dimensions (), rep (nil_rep ()), slice_data (rep->data),
       slice_len (rep->len)
-    {
-      rep->count++;
-    }
+  {
+    rep->count++;
+  }
 
   // Obsolete 1D ctor (there are no 1D arrays).
   explicit Array (octave_idx_type n) GCC_ATTR_DEPRECATED
     : dimensions (n, 1), rep (new typename Array<T>::ArrayRep (n)),
       slice_data (rep->data), slice_len (rep->len)
-    { }
+  { }
 
   // Obsolete initialized 1D ctor (there are no 1D arrays).
   explicit Array (octave_idx_type n, const T& val) GCC_ATTR_DEPRECATED
     : dimensions (n, 1), rep (new typename Array<T>::ArrayRep (n)),
       slice_data (rep->data), slice_len (rep->len)
-    {
-      fill (val);
-    }
+  {
+    fill (val);
+  }
 
   // nD uninitialized ctor.
   explicit Array (const dim_vector& dv)
     : dimensions (dv),
       rep (new typename Array<T>::ArrayRep (dv.safe_numel ())),
       slice_data (rep->data), slice_len (rep->len)
-    {
-      dimensions.chop_trailing_singletons ();
-    }
+  {
+    dimensions.chop_trailing_singletons ();
+  }
 
   // nD initialized ctor.
   explicit Array (const dim_vector& dv, const T& val)
     : dimensions (dv),
       rep (new typename Array<T>::ArrayRep (dv.safe_numel ())),
       slice_data (rep->data), slice_len (rep->len)
-    {
-      fill (val);
-      dimensions.chop_trailing_singletons ();
-    }
+  {
+    fill (val);
+    dimensions.chop_trailing_singletons ();
+  }
 
   // Reshape constructor.
   Array (const Array<T>& a, const dim_vector& dv);
@@ -225,41 +226,41 @@
     : dimensions (a.dims ()),
       rep (new typename Array<T>::ArrayRep (a.data (), a.length ())),
       slice_data (rep->data), slice_len (rep->len)
-    { }
+  { }
 
   // No type conversion case.
   Array (const Array<T>& a)
     : dimensions (a.dimensions), rep (a.rep), slice_data (a.slice_data),
       slice_len (a.slice_len)
-    {
-      rep->count++;
-    }
+  {
+    rep->count++;
+  }
 
 public:
 
   virtual ~Array (void)
-    {
-      if (--rep->count == 0)
-        delete rep;
-    }
+  {
+    if (--rep->count == 0)
+      delete rep;
+  }
 
   Array<T>& operator = (const Array<T>& a)
-    {
-      if (this != &a)
-        {
-          if (--rep->count == 0)
-            delete rep;
+  {
+    if (this != &a)
+      {
+        if (--rep->count == 0)
+          delete rep;
 
-          rep = a.rep;
-          rep->count++;
+        rep = a.rep;
+        rep->count++;
 
-          dimensions = a.dimensions;
-          slice_data = a.slice_data;
-          slice_len = a.slice_len;
-        }
+        dimensions = a.dimensions;
+        slice_data = a.slice_data;
+        slice_len = a.slice_len;
+      }
 
-      return *this;
-    }
+    return *this;
+  }
 
   void fill (const T& val);
 
@@ -267,7 +268,7 @@
   void clear (const dim_vector& dv);
 
   void clear (octave_idx_type r, octave_idx_type c)
-    { clear (dim_vector (r, c)); }
+  { clear (dim_vector (r, c)); }
 
   octave_idx_type capacity (void) const { return slice_len; }
   octave_idx_type length (void) const { return capacity (); }
@@ -280,40 +281,41 @@
 
   // Return the array as a column vector.
   Array<T> as_column (void) const
-    {
-      Array<T> retval (*this);
-      if (dimensions.length () != 2 || dimensions(1) != 1)
-        retval.dimensions = dim_vector (numel (), 1);
+  {
+    Array<T> retval (*this);
+    if (dimensions.length () != 2 || dimensions(1) != 1)
+      retval.dimensions = dim_vector (numel (), 1);
 
-      return retval;
-    }
+    return retval;
+  }
 
   // Return the array as a row vector.
   Array<T> as_row (void) const
-    {
-      Array<T> retval (*this);
-      if (dimensions.length () != 2 || dimensions(0) != 1)
-        retval.dimensions = dim_vector (1, numel ());
+  {
+    Array<T> retval (*this);
+    if (dimensions.length () != 2 || dimensions(0) != 1)
+      retval.dimensions = dim_vector (1, numel ());
 
-      return retval;
-    }
+    return retval;
+  }
 
   // Return the array as a matrix.
   Array<T> as_matrix (void) const
-    {
-      Array<T> retval (*this);
-      if (dimensions.length () != 2)
-        retval.dimensions = dimensions.redim (2);
+  {
+    Array<T> retval (*this);
+    if (dimensions.length () != 2)
+      retval.dimensions = dimensions.redim (2);
 
-      return retval;
-    }
+    return retval;
+  }
 
   octave_idx_type rows (void) const { return dim1 (); }
   octave_idx_type cols (void) const { return dim2 (); }
   octave_idx_type columns (void) const { return dim2 (); }
   octave_idx_type pages (void) const { return dim3 (); }
 
-  size_t byte_size (void) const { return static_cast<size_t> (numel ()) * sizeof (T); }
+  size_t byte_size (void) const
+  { return static_cast<size_t> (numel ()) * sizeof (T); }
 
   // Return a const-reference so that dims ()(i) works efficiently.
   const dim_vector& dims (void) const { return dimensions; }
@@ -324,34 +326,37 @@
   { dimensions.chop_trailing_singletons (); }
 
   octave_idx_type compute_index (octave_idx_type i, octave_idx_type j) const;
-  octave_idx_type compute_index (octave_idx_type i, octave_idx_type j, octave_idx_type k) const;
+  octave_idx_type compute_index (octave_idx_type i, octave_idx_type j,
+                                 octave_idx_type k) const;
   octave_idx_type compute_index (const Array<octave_idx_type>& ra_idx) const;
 
-  octave_idx_type compute_index_unchecked (const Array<octave_idx_type>& ra_idx) const
-    { return dimensions.compute_index (ra_idx.data (), ra_idx.length ()); }
+  octave_idx_type compute_index_unchecked (const Array<octave_idx_type>& ra_idx)
+  const
+  { return dimensions.compute_index (ra_idx.data (), ra_idx.length ()); }
 
   // No checking, even for multiple references, ever.
 
   T& xelem (octave_idx_type n) { return slice_data[n]; }
   crefT xelem (octave_idx_type n) const { return slice_data[n]; }
 
-  T& xelem (octave_idx_type i, octave_idx_type j) { return xelem (dim1 ()*j+i); }
-  crefT xelem (octave_idx_type i, octave_idx_type j) const { return xelem (dim1 ()*j+i); }
+  T& xelem (octave_idx_type i, octave_idx_type j)
+  { return xelem (dim1 ()*j+i); }
+  crefT xelem (octave_idx_type i, octave_idx_type j) const
+  { return xelem (dim1 ()*j+i); }
 
   T& xelem (octave_idx_type i, octave_idx_type j, octave_idx_type k)
-    { return xelem (i, dim2 ()*k+j); }
+  { return xelem (i, dim2 ()*k+j); }
   crefT xelem (octave_idx_type i, octave_idx_type j, octave_idx_type k) const
-    { return xelem (i, dim2 ()*k+j); }
+  { return xelem (i, dim2 ()*k+j); }
 
   T& xelem (const Array<octave_idx_type>& ra_idx)
-    { return xelem (compute_index_unchecked (ra_idx)); }
+  { return xelem (compute_index_unchecked (ra_idx)); }
 
   crefT xelem (const Array<octave_idx_type>& ra_idx) const
-    { return xelem (compute_index_unchecked (ra_idx)); }
+  { return xelem (compute_index_unchecked (ra_idx)); }
 
-  // FIXME -- would be nice to fix this so that we don't
-  // unnecessarily force a copy, but that is not so easy, and I see no
-  // clean way to do it.
+  // FIXME: would be nice to fix this so that we don't unnecessarily force
+  //        a copy, but that is not so easy, and I see no clean way to do it.
 
   T& checkelem (octave_idx_type n);
   T& checkelem (octave_idx_type i, octave_idx_type j);
@@ -359,54 +364,71 @@
   T& checkelem (const Array<octave_idx_type>& ra_idx);
 
   T& elem (octave_idx_type n)
-    {
-      make_unique ();
-      return xelem (n);
-    }
+  {
+    make_unique ();
+    return xelem (n);
+  }
 
   T& elem (octave_idx_type i, octave_idx_type j) { return elem (dim1 ()*j+i); }
 
-  T& elem (octave_idx_type i, octave_idx_type j, octave_idx_type k) { return elem (i, dim2 ()*k+j); }
+  T& elem (octave_idx_type i, octave_idx_type j, octave_idx_type k)
+  { return elem (i, dim2 ()*k+j); }
 
   T& elem (const Array<octave_idx_type>& ra_idx)
-    { return Array<T>::elem (compute_index_unchecked (ra_idx)); }
+  { return Array<T>::elem (compute_index_unchecked (ra_idx)); }
 
 #if defined (BOUNDS_CHECKING)
   T& operator () (octave_idx_type n) { return checkelem (n); }
-  T& operator () (octave_idx_type i, octave_idx_type j) { return checkelem (i, j); }
-  T& operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k) { return checkelem (i, j, k); }
-  T& operator () (const Array<octave_idx_type>& ra_idx) { return checkelem (ra_idx); }
+  T& operator () (octave_idx_type i, octave_idx_type j)
+  { return checkelem (i, j); }
+  T& operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k)
+  { return checkelem (i, j, k); }
+  T& operator () (const Array<octave_idx_type>& ra_idx)
+  { return checkelem (ra_idx); }
 #else
   T& operator () (octave_idx_type n) { return elem (n); }
   T& operator () (octave_idx_type i, octave_idx_type j) { return elem (i, j); }
-  T& operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k) { return elem (i, j, k); }
-  T& operator () (const Array<octave_idx_type>& ra_idx) { return elem (ra_idx); }
+  T& operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k)
+  { return elem (i, j, k); }
+  T& operator () (const Array<octave_idx_type>& ra_idx)
+  { return elem (ra_idx); }
 #endif
 
   crefT checkelem (octave_idx_type n) const;
   crefT checkelem (octave_idx_type i, octave_idx_type j) const;
-  crefT checkelem (octave_idx_type i, octave_idx_type j, octave_idx_type k) const;
+  crefT checkelem (octave_idx_type i, octave_idx_type j,
+                   octave_idx_type k) const;
   crefT checkelem (const Array<octave_idx_type>& ra_idx) const;
 
   crefT elem (octave_idx_type n) const { return xelem (n); }
 
-  crefT elem (octave_idx_type i, octave_idx_type j) const { return xelem (i, j); }
+  crefT elem (octave_idx_type i, octave_idx_type j) const
+  { return xelem (i, j); }
 
-  crefT elem (octave_idx_type i, octave_idx_type j, octave_idx_type k) const { return xelem (i, j, k); }
+  crefT elem (octave_idx_type i, octave_idx_type j, octave_idx_type k) const
+  { return xelem (i, j, k); }
 
   crefT elem (const Array<octave_idx_type>& ra_idx) const
-    { return Array<T>::xelem (compute_index_unchecked (ra_idx)); }
+  { return Array<T>::xelem (compute_index_unchecked (ra_idx)); }
 
 #if defined (BOUNDS_CHECKING)
   crefT operator () (octave_idx_type n) const { return checkelem (n); }
-  crefT operator () (octave_idx_type i, octave_idx_type j) const { return checkelem (i, j); }
-  crefT operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k) const { return checkelem (i, j, k); }
-  crefT operator () (const Array<octave_idx_type>& ra_idx) const { return checkelem (ra_idx); }
+  crefT operator () (octave_idx_type i, octave_idx_type j) const
+  { return checkelem (i, j); }
+  crefT operator () (octave_idx_type i, octave_idx_type j,
+                     octave_idx_type k) const
+  { return checkelem (i, j, k); }
+  crefT operator () (const Array<octave_idx_type>& ra_idx) const
+  { return checkelem (ra_idx); }
 #else
   crefT operator () (octave_idx_type n) const { return elem (n); }
-  crefT operator () (octave_idx_type i, octave_idx_type j) const { return elem (i, j); }
-  crefT operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k) const { return elem (i, j, k); }
-  crefT operator () (const Array<octave_idx_type>& ra_idx) const { return elem (ra_idx); }
+  crefT operator () (octave_idx_type i, octave_idx_type j) const
+  { return elem (i, j); }
+  crefT operator () (octave_idx_type i, octave_idx_type j,
+                     octave_idx_type k) const
+  { return elem (i, j, k); }
+  crefT operator () (const Array<octave_idx_type>& ra_idx) const
+  { return elem (ra_idx); }
 #endif
 
   // Fast extractors. All of these produce shallow copies.
@@ -422,14 +444,14 @@
   Array<T> linear_slice (octave_idx_type lo, octave_idx_type up) const;
 
   Array<T> reshape (octave_idx_type nr, octave_idx_type nc) const
-    { return Array<T> (*this, dim_vector (nr, nc)); }
+  { return Array<T> (*this, dim_vector (nr, nc)); }
 
   Array<T> reshape (const dim_vector& new_dims) const
-    { return Array<T> (*this, new_dims); }
+  { return Array<T> (*this, new_dims); }
 
   Array<T> permute (const Array<octave_idx_type>& vec, bool inv = false) const;
   Array<T> ipermute (const Array<octave_idx_type>& vec) const
-    { return permute (vec, true); }
+  { return permute (vec, true); }
 
   bool is_square (void) const { return (dim1 () == dim2 ()); }
 
@@ -467,7 +489,8 @@
 
   void resize (octave_idx_type n) GCC_ATTR_DEPRECATED { resize1 (n); }
 
-  void resize (octave_idx_type nr, octave_idx_type nc, const T& rfv) GCC_ATTR_DEPRECATED
+  void resize (octave_idx_type nr, octave_idx_type nc,
+               const T& rfv) GCC_ATTR_DEPRECATED
   {
     resize2 (nr, nc, rfv);
   }
@@ -481,7 +504,7 @@
   void resize (const dim_vector& dv) { resize (dv, resize_fill_value ()); }
 
   // Indexing with possible resizing and fill
-  // FIXME -- this is really a corner case, that should better be
+  // FIXME: this is really a corner case, that should better be
   // handled directly in liboctinterp.
 
   Array<T> index (const idx_vector& i, bool resize_ok, const T& rfv) const;
@@ -490,13 +513,16 @@
     return index (i, resize_ok, resize_fill_value ());
   }
 
-  Array<T> index (const idx_vector& i, const idx_vector& j, bool resize_ok, const T& rfv) const;
-  Array<T> index (const idx_vector& i, const idx_vector& j, bool resize_ok) const
+  Array<T> index (const idx_vector& i, const idx_vector& j, bool resize_ok,
+                  const T& rfv) const;
+  Array<T> index (const idx_vector& i, const idx_vector& j,
+                  bool resize_ok) const
   {
     return index (i, j, resize_ok, resize_fill_value ());
   }
 
-  Array<T> index (const Array<idx_vector>& ia, bool resize_ok, const T& rfv) const;
+  Array<T> index (const Array<idx_vector>& ia, bool resize_ok,
+                  const T& rfv) const;
   Array<T> index (const Array<idx_vector>& ia, bool resize_ok) const
   {
     return index (ia, resize_ok, resize_fill_value ());
@@ -510,7 +536,8 @@
     assign (i, rhs, resize_fill_value ());
   }
 
-  void assign (const idx_vector& i, const idx_vector& j, const Array<T>& rhs, const T& rfv);
+  void assign (const idx_vector& i, const idx_vector& j, const Array<T>& rhs,
+               const T& rfv);
   void assign (const idx_vector& i, const idx_vector& j, const Array<T>& rhs)
   {
     assign (i, j, rhs, resize_fill_value ());
@@ -543,15 +570,15 @@
   Array<T>& insert (const Array<T>& a, octave_idx_type r, octave_idx_type c);
 
   void maybe_economize (void)
-    {
-      if (rep->count == 1 && slice_len != rep->len)
-        {
-          ArrayRep *new_rep = new ArrayRep (slice_data, slice_len);
-          delete rep;
-          rep = new_rep;
-          slice_data = rep->data;
-        }
-    }
+  {
+    if (rep->count == 1 && slice_len != rep->len)
+      {
+        ArrayRep *new_rep = new ArrayRep (slice_data, slice_len);
+        delete rep;
+        rep = new_rep;
+        slice_data = rep->data;
+      }
+  }
 
   void print_info (std::ostream& os, const std::string& prefix) const;
 
@@ -578,14 +605,16 @@
 
   // Ditto, but for an array of values, specializing on the case when values
   // are sorted. NaNs get the value N.
-  Array<octave_idx_type> lookup (const Array<T>& values, sortmode mode = UNSORTED) const;
+  Array<octave_idx_type> lookup (const Array<T>& values,
+                                 sortmode mode = UNSORTED) const;
 
   // Count nonzero elements.
   octave_idx_type nnz (void) const;
 
   // Find indices of (at most n) nonzero elements. If n is specified, backward
   // specifies search from backward.
-  Array<octave_idx_type> find (octave_idx_type n = -1, bool backward = false) const;
+  Array<octave_idx_type> find (octave_idx_type n = -1,
+                               bool backward = false) const;
 
   // Returns the n-th element in increasing order, using the same ordering as
   // used for sort. n can either be a scalar index or a contiguous range.
@@ -691,7 +720,7 @@
 private:
 
   void resize2 (octave_idx_type nr, octave_idx_type nc, const T& rfv);
-  void resize2 (octave_idx_type nr, octave_idx_type nc)                
+  void resize2 (octave_idx_type nr, octave_idx_type nc)
   {
     resize2 (nr, nc, resize_fill_value ());
   }
@@ -723,13 +752,13 @@
     explicit NoAlias (X x, Y y, Z z) : ArrayClass (x, y, z) { }
 
   T& operator () (octave_idx_type n)
-    { return ArrayClass::xelem (n); }
+  { return ArrayClass::xelem (n); }
   T& operator () (octave_idx_type i, octave_idx_type j)
-    { return ArrayClass::xelem (i, j); }
+  { return ArrayClass::xelem (i, j); }
   T& operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k)
-    { return ArrayClass::xelem (i, j, k); }
+  { return ArrayClass::xelem (i, j, k); }
   T& operator () (const Array<octave_idx_type>& ra_idx)
-    { return ArrayClass::xelem (ra_idx); }
+  { return ArrayClass::xelem (ra_idx); }
 };
 
 template <class T>

--- a/liboctave/array/Array3.h	Sat Oct 26 23:20:30 2013 +0200
+++ b/liboctave/array/Array3.h	Sat Oct 26 18:57:05 2013 -0700
@@ -42,7 +42,8 @@
 
   Array3 (void) : Array<T> (dim_vector (0, 0, 0)) { }
 
-  Array3 (octave_idx_type r, octave_idx_type c, octave_idx_type p) : Array<T> (dim_vector (r, c, p)) { }
+  Array3 (octave_idx_type r, octave_idx_type c,
+          octave_idx_type p) : Array<T> (dim_vector (r, c, p)) { }
 
   Array3 (octave_idx_type r, octave_idx_type c, octave_idx_type p, const T& val)
     : Array<T> (dim_vector (r, c, p), val) { }
@@ -50,37 +51,39 @@
   Array3 (const Array3<T>& a)
     : Array<T> (a, a.dims ()) { }
 
-  Array3 (const Array<T>& a, octave_idx_type r, octave_idx_type c, octave_idx_type p)
+  Array3 (const Array<T>& a, octave_idx_type r, octave_idx_type c,
+          octave_idx_type p)
     : Array<T> (a, dim_vector (r, c, p)) { }
 
   ~Array3 (void) { }
 
   Array3<T>& operator = (const Array3<T>& a)
-    {
-      if (this != &a)
-        Array<T>::operator = (a);
+  {
+    if (this != &a)
+      Array<T>::operator = (a);
 
-      return *this;
-    }
+    return *this;
+  }
 
   void resize (octave_idx_type r, octave_idx_type c, octave_idx_type p)
-    { Array<T>::resize (dim_vector (r, c, p)); }
+  { Array<T>::resize (dim_vector (r, c, p)); }
 
-  void resize (octave_idx_type r, octave_idx_type c, octave_idx_type p, const T& val)
-    { Array<T>::resize (dim_vector (r, c, p), val); }
+  void resize (octave_idx_type r, octave_idx_type c, octave_idx_type p,
+               const T& val)
+  { Array<T>::resize (dim_vector (r, c, p), val); }
 
   Array3<T> sort (octave_idx_type dim = 0, sortmode mode = ASCENDING) const
-    {
-      Array<T> tmp = Array<T>::sort (dim, mode);
-      return Array3<T> (tmp, tmp.rows (), tmp.columns (), tmp.pages ());
-    }
+  {
+    Array<T> tmp = Array<T>::sort (dim, mode);
+    return Array3<T> (tmp, tmp.rows (), tmp.columns (), tmp.pages ());
+  }
 
   Array3<T> sort (Array<octave_idx_type> &sidx, octave_idx_type dim = 0,
-                 sortmode mode = ASCENDING) const
-    {
-      Array<T> tmp = Array<T>::sort (sidx, dim, mode);
-      return Array3<T> (tmp, tmp.rows (), tmp.columns (), tmp.pages ());
-    }
+                  sortmode mode = ASCENDING) const
+  {
+    Array<T> tmp = Array<T>::sort (sidx, dim, mode);
+    return Array3<T> (tmp, tmp.rows (), tmp.columns (), tmp.pages ());
+  }
 };
 
 // If we're with GNU C++, issue a warning.

--- a/liboctave/array/CColVector.cc	Sat Oct 26 23:20:30 2013 +0200
+++ b/liboctave/array/CColVector.cc	Sat Oct 26 18:57:05 2013 -0700
@@ -53,7 +53,7 @@
 // Complex Column Vector class
 
 ComplexColumnVector::ComplexColumnVector (const ColumnVector& a)
-   : MArray<Complex> (a)
+  : MArray<Complex> (a)
 {
 }
 
@@ -176,7 +176,8 @@
 }
 
 ComplexColumnVector&
-ComplexColumnVector::fill (const Complex& val, octave_idx_type r1, octave_idx_type r2)
+ComplexColumnVector::fill (const Complex& val,
+                           octave_idx_type r1, octave_idx_type r2)
 {
   octave_idx_type len = length ();
 

--- a/liboctave/array/CColVector.h	Sat Oct 26 23:20:30 2013 +0200
+++ b/liboctave/array/CColVector.h	Sat Oct 26 18:57:05 2013 -0700
@@ -32,8 +32,8 @@
 OCTAVE_API
 ComplexColumnVector : public MArray<Complex>
 {
-friend class ComplexMatrix;
-friend class ComplexRowVector;
+  friend class ComplexMatrix;
+  friend class ComplexRowVector;
 
 public:
 
@@ -59,10 +59,10 @@
   explicit ComplexColumnVector (const ColumnVector& a);
 
   ComplexColumnVector& operator = (const ComplexColumnVector& a)
-    {
-      MArray<Complex>::operator = (a);
-      return *this;
-    }
+  {
+    MArray<Complex>::operator = (a);
+    return *this;
+  }
 
   bool operator == (const ComplexColumnVector& a) const;
   bool operator != (const ComplexColumnVector& a) const;
@@ -74,8 +74,10 @@
 
   ComplexColumnVector& fill (double val);
   ComplexColumnVector& fill (const Complex& val);
-  ComplexColumnVector& fill (double val, octave_idx_type r1, octave_idx_type r2);
-  ComplexColumnVector& fill (const Complex& val, octave_idx_type r1, octave_idx_type r2);
+  ComplexColumnVector& fill (double val,
+                             octave_idx_type r1, octave_idx_type r2);
+  ComplexColumnVector& fill (const Complex& val,
+                             octave_idx_type r1, octave_idx_type r2);
 
   ComplexColumnVector stack (const ColumnVector& a) const;
   ComplexColumnVector stack (const ComplexColumnVector& a) const;
@@ -99,26 +101,26 @@
   // matrix by column vector -> column vector operations
 
   friend OCTAVE_API ComplexColumnVector operator * (const ComplexMatrix& a,
-                                         const ColumnVector& b);
+                                                    const ColumnVector& b);
 
   friend OCTAVE_API ComplexColumnVector operator * (const ComplexMatrix& a,
-                                         const ComplexColumnVector& b);
+                                                    const ComplexColumnVector& b);
 
   // matrix by column vector -> column vector operations
 
   friend OCTAVE_API ComplexColumnVector operator * (const Matrix& a,
-                                         const ComplexColumnVector& b);
+                                                    const ComplexColumnVector& b);
 
   // diagonal matrix by column vector -> column vector operations
 
   friend OCTAVE_API ComplexColumnVector operator * (const DiagMatrix& a,
-                                         const ComplexColumnVector& b);
+                                                    const ComplexColumnVector& b);
 
   friend OCTAVE_API ComplexColumnVector operator * (const ComplexDiagMatrix& a,
-                                         const ColumnVector& b);
+                                                    const ColumnVector& b);
 
   friend OCTAVE_API ComplexColumnVector operator * (const ComplexDiagMatrix& a,
-                                         const ComplexColumnVector& b);
+                                                    const ComplexColumnVector& b);
 
   // other operations
 
@@ -129,8 +131,10 @@
 
   // i/o
 
-  friend OCTAVE_API std::ostream& operator << (std::ostream& os, const ComplexColumnVector& a);
-  friend OCTAVE_API std::istream& operator >> (std::istream& is, ComplexColumnVector& a);
+  friend OCTAVE_API std::ostream& operator << (std::ostream& os,
+                                               const ComplexColumnVector& a);
+  friend OCTAVE_API std::istream& operator >> (std::istream& is,
+                                               ComplexColumnVector& a);
 
   void resize (octave_idx_type n, const Complex& rfv = Complex (0))
   {
@@ -138,7 +142,7 @@
   }
 
   void clear (octave_idx_type n)
-    { Array<Complex>::clear (n, 1); }
+  { Array<Complex>::clear (n, 1); }
 
 };
 

--- a/liboctave/array/CDiagMatrix.cc	Sat Oct 26 23:20:30 2013 +0200
+++ b/liboctave/array/CDiagMatrix.cc	Sat Oct 26 18:57:05 2013 -0700
@@ -91,7 +91,8 @@
 }
 
 ComplexDiagMatrix&
-ComplexDiagMatrix::fill (const Complex& val, octave_idx_type beg, octave_idx_type end)
+ComplexDiagMatrix::fill (const Complex& val,
+                         octave_idx_type beg, octave_idx_type end)
 {
   if (beg < 0 || end >= length () || end < beg)
     {
@@ -248,7 +249,8 @@
 // resize is the destructive analog for this one
 
 ComplexMatrix
-ComplexDiagMatrix::extract (octave_idx_type r1, octave_idx_type c1, octave_idx_type r2, octave_idx_type c2) const
+ComplexDiagMatrix::extract (octave_idx_type r1, octave_idx_type c1,
+                            octave_idx_type r2, octave_idx_type c2) const
 {
   if (r1 > r2) { std::swap (r1, r2); }
   if (c1 > c2) { std::swap (c1, c2); }

--- a/liboctave/array/CDiagMatrix.h	Sat Oct 26 23:20:30 2013 +0200
+++ b/liboctave/array/CDiagMatrix.h	Sat Oct 26 18:57:05 2013 -0700
@@ -41,7 +41,8 @@
 
   ComplexDiagMatrix (void) : MDiagArray2<Complex> () { }
 
-  ComplexDiagMatrix (octave_idx_type r, octave_idx_type c) : MDiagArray2<Complex> (r, c) { }
+  ComplexDiagMatrix (octave_idx_type r, octave_idx_type c)
+    : MDiagArray2<Complex> (r, c) { }
 
   ComplexDiagMatrix (octave_idx_type r, octave_idx_type c, const Complex& val)
     : MDiagArray2<Complex> (r, c, val) { }
@@ -52,7 +53,8 @@
   explicit ComplexDiagMatrix (const Array<double>& a)
     : MDiagArray2<Complex> (Array<Complex> (a)) { }
 
-  ComplexDiagMatrix (const Array<Complex>& a, octave_idx_type r, octave_idx_type c)
+  ComplexDiagMatrix (const Array<Complex>& a, octave_idx_type r,
+                     octave_idx_type c)
     : MDiagArray2<Complex> (a, r, c) { }
 
   explicit ComplexDiagMatrix (const DiagMatrix& a);
@@ -68,18 +70,20 @@
     : MDiagArray2<Complex> (a) { }
 
   ComplexDiagMatrix& operator = (const ComplexDiagMatrix& a)
-    {
-      MDiagArray2<Complex>::operator = (a);
-      return *this;
-    }
+  {
+    MDiagArray2<Complex>::operator = (a);
+    return *this;
+  }
 
   bool operator == (const ComplexDiagMatrix& a) const;
   bool operator != (const ComplexDiagMatrix& a) const;
 
   ComplexDiagMatrix& fill (double val);
   ComplexDiagMatrix& fill (const Complex& val);
-  ComplexDiagMatrix& fill (double val, octave_idx_type beg, octave_idx_type end);
-  ComplexDiagMatrix& fill (const Complex& val, octave_idx_type beg, octave_idx_type end);
+  ComplexDiagMatrix& fill (double val,
+                           octave_idx_type beg, octave_idx_type end);
+  ComplexDiagMatrix& fill (const Complex& val,
+                           octave_idx_type beg, octave_idx_type end);
   ComplexDiagMatrix& fill (const ColumnVector& a);
   ComplexDiagMatrix& fill (const ComplexColumnVector& a);
   ComplexDiagMatrix& fill (const RowVector& a);
@@ -89,15 +93,18 @@
   ComplexDiagMatrix& fill (const RowVector& a, octave_idx_type beg);
   ComplexDiagMatrix& fill (const ComplexRowVector& a, octave_idx_type beg);
 
-  ComplexDiagMatrix hermitian (void) const { return MDiagArray2<Complex>::hermitian (std::conj); }
-  ComplexDiagMatrix transpose (void) const { return MDiagArray2<Complex>::transpose (); }
+  ComplexDiagMatrix hermitian (void) const
+  { return MDiagArray2<Complex>::hermitian (std::conj); }
+  ComplexDiagMatrix transpose (void) const
+  { return MDiagArray2<Complex>::transpose (); }
   DiagMatrix abs (void) const;
 
   friend OCTAVE_API ComplexDiagMatrix conj (const ComplexDiagMatrix& a);
 
   // resize is the destructive analog for this one
 
-  ComplexMatrix extract (octave_idx_type r1, octave_idx_type c1, octave_idx_type r2, octave_idx_type c2) const;
+  ComplexMatrix extract (octave_idx_type r1, octave_idx_type c1,
+                         octave_idx_type r2, octave_idx_type c2) const;
 
   // extract row or column i
 
@@ -121,14 +128,15 @@
   // other operations
 
   ComplexColumnVector extract_diag (octave_idx_type k = 0) const
-    { return MDiagArray2<Complex>::extract_diag (k); }
+  { return MDiagArray2<Complex>::extract_diag (k); }
 
   ComplexDET determinant (void) const;
   double rcond (void) const;
 
   // i/o
 
-  friend std::ostream& operator << (std::ostream& os, const ComplexDiagMatrix& a);
+  friend std::ostream& operator << (std::ostream& os,
+                                    const ComplexDiagMatrix& a);
 
 };
 

--- a/liboctave/array/CMatrix.cc	Sat Oct 26 23:20:30 2013 +0200
+++ b/liboctave/array/CMatrix.cc	Sat Oct 26 18:57:05 2013 -0700
@@ -300,8 +300,7 @@
     elem (i, i) = a.elem (i, i);
 }
 
-// FIXME -- could we use a templated mixed-type copy function
-// here?
+// FIXME: could we use a templated mixed-type copy function here?
 
 ComplexMatrix::ComplexMatrix (const boolMatrix& a)
   : MArray<Complex> (a)
@@ -410,7 +409,8 @@
 }
 
 ComplexMatrix&
-ComplexMatrix::insert (const ColumnVector& a, octave_idx_type r, octave_idx_type c)
+ComplexMatrix::insert (const ColumnVector& a,
+                       octave_idx_type r, octave_idx_type c)
 {
   octave_idx_type a_len = a.length ();
 
@@ -432,7 +432,8 @@
 }
 
 ComplexMatrix&
-ComplexMatrix::insert (const DiagMatrix& a, octave_idx_type r, octave_idx_type c)
+ComplexMatrix::insert (const DiagMatrix& a,
+                       octave_idx_type r, octave_idx_type c)
 {
   octave_idx_type a_nr = a.rows ();
   octave_idx_type a_nc = a.cols ();
@@ -459,14 +460,16 @@
 }
 
 ComplexMatrix&
-ComplexMatrix::insert (const ComplexMatrix& a, octave_idx_type r, octave_idx_type c)
+ComplexMatrix::insert (const ComplexMatrix& a,
+                       octave_idx_type r, octave_idx_type c)
 {
   Array<Complex>::insert (a, r, c);
   return *this;
 }
 
 ComplexMatrix&
-ComplexMatrix::insert (const ComplexRowVector& a, octave_idx_type r, octave_idx_type c)
+ComplexMatrix::insert (const ComplexRowVector& a,
+                       octave_idx_type r, octave_idx_type c)
 {
   octave_idx_type a_len = a.length ();
   if (r < 0 || r >= rows () || c < 0 || c + a_len > cols ())
@@ -482,7 +485,8 @@
 }
 
 ComplexMatrix&
-ComplexMatrix::insert (const ComplexColumnVector& a, octave_idx_type r, octave_idx_type c)
+ComplexMatrix::insert (const ComplexColumnVector& a,
+                       octave_idx_type r, octave_idx_type c)
 {
   octave_idx_type a_len = a.length ();
 
@@ -504,7 +508,8 @@
 }
 
 ComplexMatrix&
-ComplexMatrix::insert (const ComplexDiagMatrix& a, octave_idx_type r, octave_idx_type c)
+ComplexMatrix::insert (const ComplexDiagMatrix& a,
+                       octave_idx_type r, octave_idx_type c)
 {
   octave_idx_type a_nr = a.rows ();
   octave_idx_type a_nc = a.cols ();
@@ -567,7 +572,8 @@
 }
 
 ComplexMatrix&
-ComplexMatrix::fill (double val, octave_idx_type r1, octave_idx_type c1, octave_idx_type r2, octave_idx_type c2)
+ComplexMatrix::fill (double val, octave_idx_type r1, octave_idx_type c1,
+                     octave_idx_type r2, octave_idx_type c2)
 {
   octave_idx_type nr = rows ();
   octave_idx_type nc = cols ();
@@ -595,7 +601,8 @@
 }
 
 ComplexMatrix&
-ComplexMatrix::fill (const Complex& val, octave_idx_type r1, octave_idx_type c1, octave_idx_type r2, octave_idx_type c2)
+ComplexMatrix::fill (const Complex& val, octave_idx_type r1, octave_idx_type c1,
+                     octave_idx_type r2, octave_idx_type c2)
 {
   octave_idx_type nr = rows ();
   octave_idx_type nc = cols ();
@@ -927,7 +934,8 @@
 // resize is the destructive equivalent for this one
 
 ComplexMatrix
-ComplexMatrix::extract (octave_idx_type r1, octave_idx_type c1, octave_idx_type r2, octave_idx_type c2) const
+ComplexMatrix::extract (octave_idx_type r1, octave_idx_type c1,
+                        octave_idx_type r2, octave_idx_type c2) const
 {
   if (r1 > r2) { std::swap (r1, r2); }
   if (c1 > c2) { std::swap (c1, c2); }
@@ -936,7 +944,8 @@
 }
 
 ComplexMatrix
-ComplexMatrix::extract_n (octave_idx_type r1, octave_idx_type c1, octave_idx_type nr, octave_idx_type nc) const
+ComplexMatrix::extract_n (octave_idx_type r1, octave_idx_type c1,
+                          octave_idx_type nr, octave_idx_type nc) const
 {
   return index (idx_vector (r1, r1 + nr), idx_vector (c1, c1 + nc));
 }
@@ -1089,7 +1098,8 @@
       // Calculate the norm of the matrix, for later use.
       double anorm;
       if (calc_cond)
-        anorm = retval.abs ().sum ().row (static_cast<octave_idx_type>(0)).max ();
+        anorm = retval.abs ().sum ().row (static_cast<octave_idx_type>(0))
+                .max ();
 
       F77_XFCN (zgetrf, ZGETRF, (nc, nc, tmp_data, nr, pipvt, info));
 
@@ -1558,7 +1568,8 @@
 }
 
 ComplexDET
-ComplexMatrix::determinant (octave_idx_type& info, double& rcon, int calc_cond) const
+ComplexMatrix::determinant (octave_idx_type& info, double& rcon,
+                            int calc_cond) const
 {
   MatrixType mattype (*this);
   return determinant (mattype, info, rcon, calc_cond);
@@ -1796,7 +1807,7 @@
               Complex *tmp_data = atmp.fortran_vec ();
 
               anorm = atmp.abs().sum().
-                row(static_cast<octave_idx_type>(0)).max();
+                      row(static_cast<octave_idx_type>(0)).max();
 
               F77_XFCN (zpotrf, ZPOTRF, (F77_CONST_CHAR_ARG2 (&job, 1), nr,
                                          tmp_data, nr, info
@@ -1839,7 +1850,7 @@
 
               if (anorm < 0.)
                 anorm = atmp.abs ().sum ().
-                  row(static_cast<octave_idx_type>(0)).max ();
+                        row(static_cast<octave_idx_type>(0)).max ();
 
               Array<Complex> z (dim_vector (2 * nc, 1));
               Complex *pz = z.fortran_vec ();
@@ -2096,7 +2107,7 @@
     {
       volatile int typ = mattype.type ();
 
-     // Calculate the norm of the matrix, for later use.
+      // Calculate the norm of the matrix, for later use.
       double anorm = -1.;
 
       if (typ == MatrixType::Hermitian)
@@ -2191,7 +2202,8 @@
 
           // Calculate the norm of the matrix, for later use.
           if (anorm < 0.)
-            anorm = atmp.abs ().sum ().row (static_cast<octave_idx_type>(0)).max ();
+            anorm = atmp.abs ().sum ().row (static_cast<octave_idx_type>(0))
+                    .max ();
 
           F77_XFCN (zgetrf, ZGETRF, (nr, nr, tmp_data, nr, pipvt, info));
 
@@ -2334,9 +2346,11 @@
   else if (typ == MatrixType::Lower || typ == MatrixType::Permuted_Lower)
     retval = ltsolve (mattype, b, info, rcon, sing_handler, false, transt);
   else if (transt == blas_trans)
-    return transpose ().solve (mattype, b, info, rcon, sing_handler, singular_fallback);
+    return transpose ().solve (mattype, b, info, rcon, sing_handler,
+                               singular_fallback);
   else if (transt == blas_conj_trans)
-    retval = hermitian ().solve (mattype, b, info, rcon, sing_handler, singular_fallback);
+    retval = hermitian ().solve (mattype, b, info, rcon, sing_handler,
+                                 singular_fallback);
   else if (typ == MatrixType::Full || typ == MatrixType::Hermitian)
     retval = fsolve (mattype, b, info, rcon, sing_handler, true);
   else if (typ != MatrixType::Rectangular)
@@ -2381,7 +2395,8 @@
 ComplexColumnVector
 ComplexMatrix::solve (MatrixType &typ, const ColumnVector& b,
                       octave_idx_type& info, double& rcon,
-                      solve_singularity_handler sing_handler, blas_trans_type transt) const
+                      solve_singularity_handler sing_handler,
+                      blas_trans_type transt) const
 {
   return solve (typ, ComplexColumnVector (b), info, rcon, sing_handler, transt);
 }
@@ -2412,7 +2427,8 @@
 ComplexColumnVector
 ComplexMatrix::solve (MatrixType &typ, const ComplexColumnVector& b,
                       octave_idx_type& info, double& rcon,
-                      solve_singularity_handler sing_handler, blas_trans_type transt) const
+                      solve_singularity_handler sing_handler,
+                      blas_trans_type transt) const
 {
 
   ComplexMatrix tmp (b);
@@ -2436,14 +2452,16 @@
 }
 
 ComplexMatrix
-ComplexMatrix::solve (const Matrix& b, octave_idx_type& info, double& rcon) const
+ComplexMatrix::solve (const Matrix& b, octave_idx_type& info,
+                      double& rcon) const
 {
   return solve (b, info, rcon, 0);
 }
 
 ComplexMatrix
 ComplexMatrix::solve (const Matrix& b, octave_idx_type& info, double& rcon,
-                      solve_singularity_handler sing_handler, blas_trans_type transt) const
+                      solve_singularity_handler sing_handler,
+                      blas_trans_type transt) const
 {
   ComplexMatrix tmp (b);
   return solve (tmp, info, rcon, sing_handler, transt);
@@ -2465,14 +2483,17 @@
 }
 
 ComplexMatrix
-ComplexMatrix::solve (const ComplexMatrix& b, octave_idx_type& info, double& rcon) const
+ComplexMatrix::solve (const ComplexMatrix& b, octave_idx_type& info,
+                      double& rcon) const
 {
   return solve (b, info, rcon, 0);
 }
 
 ComplexMatrix
-ComplexMatrix::solve (const ComplexMatrix& b, octave_idx_type& info, double& rcon,
-                      solve_singularity_handler sing_handler, blas_trans_type transt) const
+ComplexMatrix::solve (const ComplexMatrix& b, octave_idx_type& info,
+                      double& rcon,
+                      solve_singularity_handler sing_handler,
+                      blas_trans_type transt) const
 {
   MatrixType mattype (*this);
   return solve (mattype, b, info, rcon, sing_handler, true, transt);
@@ -2503,7 +2524,8 @@
 ComplexColumnVector
 ComplexMatrix::solve (const ColumnVector& b, octave_idx_type& info,
                       double& rcon,
-                      solve_singularity_handler sing_handler, blas_trans_type transt) const
+                      solve_singularity_handler sing_handler,
+                      blas_trans_type transt) const
 {
   return solve (ComplexColumnVector (b), info, rcon, sing_handler, transt);
 }
@@ -2533,7 +2555,8 @@
 ComplexColumnVector
 ComplexMatrix::solve (const ComplexColumnVector& b, octave_idx_type& info,
                       double& rcon,
-                      solve_singularity_handler sing_handler, blas_trans_type transt) const
+                      solve_singularity_handler sing_handler,
+                      blas_trans_type transt) const
 {
   MatrixType mattype (*this);
   return solve (mattype, b, info, rcon, sing_handler, transt);
@@ -2670,8 +2693,9 @@
         nlvl = 0;
 
       octave_idx_type lrwork = minmn*(10 + 2*smlsiz + 8*nlvl)
-        + 3*smlsiz*nrhs + std::max ((smlsiz+1)*(smlsiz+1),
-                                    n*(1+nrhs) + 2*nrhs);
+                               + 3*smlsiz*nrhs
+                               + std::max ((smlsiz+1)*(smlsiz+1),
+                                           n*(1+nrhs) + 2*nrhs);
       if (lrwork < 1)
         lrwork = 1;
       Array<double> rwork (dim_vector (lrwork, 1));
@@ -2778,7 +2802,8 @@
 }
 
 ComplexColumnVector
-ComplexMatrix::lssolve (const ComplexColumnVector& b, octave_idx_type& info) const
+ComplexMatrix::lssolve (const ComplexColumnVector& b,
+                        octave_idx_type& info) const
 {
   octave_idx_type rank;
   double rcon;
@@ -2860,7 +2885,7 @@
         nlvl = 0;
 
       octave_idx_type lrwork = minmn*(10 + 2*smlsiz + 8*nlvl)
-        + 3*smlsiz*nrhs + (smlsiz+1)*(smlsiz+1);
+                               + 3*smlsiz*nrhs + (smlsiz+1)*(smlsiz+1);
       if (lrwork < 1)
         lrwork = 1;
       Array<double> rwork (dim_vector (lrwork, 1));
@@ -3172,8 +3197,7 @@
   return test_any (xtoo_large_for_float);
 }
 
-// FIXME Do these really belong here?  Maybe they should be
-// in a base class?
+// FIXME: Do these really belong here?  Maybe they should be in a base class?
 
 boolMatrix
 ComplexMatrix::all (int dim) const
@@ -3319,7 +3343,8 @@
 
               if (! xisnan (tmp_min))
                 {
-                  abs_min = real_only ? std::real (tmp_min) : std::abs (tmp_min);
+                  abs_min = real_only ? std::real (tmp_min)
+                                      : std::abs (tmp_min);
                   break;
                 }
             }
@@ -3393,7 +3418,8 @@
 
               if (! xisnan (tmp_max))
                 {
-                  abs_max = real_only ? std::real (tmp_max) : std::abs (tmp_max);
+                  abs_max = real_only ? std::real (tmp_max)
+                                      : std::abs (tmp_max);
                   break;
                 }
             }
@@ -3467,7 +3493,8 @@
 
               if (! xisnan (tmp_min))
                 {
-                  abs_min = real_only ? std::real (tmp_min) : std::abs (tmp_min);
+                  abs_min = real_only ? std::real (tmp_min)
+                                      : std::abs (tmp_min);
                   break;
                 }
             }
@@ -3541,7 +3568,8 @@
 
               if (! xisnan (tmp_max))
                 {
-                  abs_max = real_only ? std::real (tmp_max) : std::abs (tmp_max);
+                  abs_max = real_only ? std::real (tmp_max)
+                                      : std::abs (tmp_max);
                   break;
                 }
             }
@@ -3645,8 +3673,7 @@
 {
   ComplexMatrix retval;
 
-  // FIXME -- need to check that a, b, and c are all the same
-  // size.
+  // FIXME: need to check that a, b, and c are all the same size.
 
   // Compute Schur decompositions
 
@@ -3663,8 +3690,7 @@
 
   ComplexMatrix cx = ua.hermitian () * c * ub;
 
-  // Solve the sylvester equation, back-transform, and return the
-  // solution.
+  // Solve the sylvester equation, back-transform, and return the solution.
 
   octave_idx_type a_nr = a.rows ();
   octave_idx_type b_nr = b.rows ();
@@ -3683,7 +3709,7 @@
                              F77_CHAR_ARG_LEN (1)
                              F77_CHAR_ARG_LEN (1)));
 
-  // FIXME -- check info?
+  // FIXME: check info?
 
   retval = -ua * cx * ub.hermitian ();
 
@@ -3764,7 +3790,7 @@
         {
           octave_idx_type lda = a.rows ();
 
-          // FIXME -- looking at the reference BLAS, it appears that it
+          // FIXME: looking at the reference BLAS, it appears that it
           // should not be necessary to initialize the output matrix if
           // BETA is 0 in the call to ZHERK, but ATLAS appears to
           // use the result matrix before zeroing the elements.
@@ -3812,13 +3838,16 @@
             {
               if (cja == cjb)
                 {
-                  F77_FUNC (xzdotu, XZDOTU) (a_nc, a.data (), 1, b.data (), 1, *c);
+                  F77_FUNC (xzdotu, XZDOTU) (a_nc, a.data (), 1, b.data (), 1,
+                                             *c);
                   if (cja) *c = std::conj (*c);
                 }
               else if (cja)
-                  F77_FUNC (xzdotc, XZDOTC) (a_nc, a.data (), 1, b.data (), 1, *c);
+                F77_FUNC (xzdotc, XZDOTC) (a_nc, a.data (), 1, b.data (), 1,
+                                           *c);
               else
-                  F77_FUNC (xzdotc, XZDOTC) (a_nc, b.data (), 1, a.data (), 1, *c);
+                F77_FUNC (xzdotc, XZDOTC) (a_nc, b.data (), 1, a.data (), 1,
+                                           *c);
             }
           else if (b_nc == 1 && ! cjb)
             {
@@ -3859,8 +3888,7 @@
   return xgemm (a, b);
 }
 
-// FIXME -- it would be nice to share code among the min/max
-// functions below.
+// FIXME: it would be nice to share code among the min/max functions below.
 
 #define EMPTY_RETURN_CHECK(T) \
   if (nr == 0 || nc == 0) \
@@ -4055,7 +4083,8 @@
   octave_idx_type m = x1.length ();
 
   if (x2.length () != m)
-    (*current_liboctave_error_handler) ("linspace: vectors must be of equal length");
+    (*current_liboctave_error_handler)
+      ("linspace: vectors must be of equal length");
 
   NoAlias<ComplexMatrix> retval;
 

--- a/liboctave/array/CMatrix.h	Sat Oct 26 23:20:30 2013 +0200
+++ b/liboctave/array/CMatrix.h	Sat Oct 26 18:57:05 2013 -0700
@@ -85,10 +85,10 @@
   explicit ComplexMatrix (const charMatrix& a);
 
   ComplexMatrix& operator = (const ComplexMatrix& a)
-    {
-      MArray<Complex>::operator = (a);
-      return *this;
-    }
+  {
+    MArray<Complex>::operator = (a);
+    return *this;
+  }
 
   bool operator == (const ComplexMatrix& a) const;
   bool operator != (const ComplexMatrix& a) const;
@@ -98,19 +98,30 @@
   // destructive insert/delete/reorder operations
 
   ComplexMatrix& insert (const Matrix& a, octave_idx_type r, octave_idx_type c);
-  ComplexMatrix& insert (const RowVector& a, octave_idx_type r, octave_idx_type c);
-  ComplexMatrix& insert (const ColumnVector& a, octave_idx_type r, octave_idx_type c);
-  ComplexMatrix& insert (const DiagMatrix& a, octave_idx_type r, octave_idx_type c);
+  ComplexMatrix& insert (const RowVector& a,
+                         octave_idx_type r, octave_idx_type c);
+  ComplexMatrix& insert (const ColumnVector& a,
+                         octave_idx_type r, octave_idx_type c);
+  ComplexMatrix& insert (const DiagMatrix& a,
+                         octave_idx_type r, octave_idx_type c);
 
-  ComplexMatrix& insert (const ComplexMatrix& a, octave_idx_type r, octave_idx_type c);
-  ComplexMatrix& insert (const ComplexRowVector& a, octave_idx_type r, octave_idx_type c);
-  ComplexMatrix& insert (const ComplexColumnVector& a, octave_idx_type r, octave_idx_type c);
-  ComplexMatrix& insert (const ComplexDiagMatrix& a, octave_idx_type r, octave_idx_type c);
+  ComplexMatrix& insert (const ComplexMatrix& a,
+                         octave_idx_type r, octave_idx_type c);
+  ComplexMatrix& insert (const ComplexRowVector& a,
+                         octave_idx_type r, octave_idx_type c);
+  ComplexMatrix& insert (const ComplexColumnVector& a,
+                         octave_idx_type r, octave_idx_type c);
+  ComplexMatrix& insert (const ComplexDiagMatrix& a,
+                         octave_idx_type r, octave_idx_type c);
 
   ComplexMatrix& fill (double val);
   ComplexMatrix& fill (const Complex& val);
-  ComplexMatrix& fill (double val, octave_idx_type r1, octave_idx_type c1, octave_idx_type r2, octave_idx_type c2);
-  ComplexMatrix& fill (const Complex& val, octave_idx_type r1, octave_idx_type c1, octave_idx_type r2, octave_idx_type c2);
+  ComplexMatrix& fill (double val,
+                       octave_idx_type r1, octave_idx_type c1,
+                       octave_idx_type r2, octave_idx_type c2);
+  ComplexMatrix& fill (const Complex& val,
+                       octave_idx_type r1, octave_idx_type c1,
+                       octave_idx_type r2, octave_idx_type c2);
 
   ComplexMatrix append (const Matrix& a) const;
   ComplexMatrix append (const RowVector& a) const;
@@ -133,17 +144,19 @@
   ComplexMatrix stack (const ComplexDiagMatrix& a) const;
 
   ComplexMatrix hermitian (void) const
-    { return MArray<Complex>::hermitian (std::conj); }
+  { return MArray<Complex>::hermitian (std::conj); }
   ComplexMatrix transpose (void) const
-    { return MArray<Complex>::transpose (); }
+  { return MArray<Complex>::transpose (); }
 
   friend OCTAVE_API ComplexMatrix conj (const ComplexMatrix& a);
 
   // resize is the destructive equivalent for this one
 
-  ComplexMatrix extract (octave_idx_type r1, octave_idx_type c1, octave_idx_type r2, octave_idx_type c2) const;
+  ComplexMatrix extract (octave_idx_type r1, octave_idx_type c1,
+                         octave_idx_type r2, octave_idx_type c2) const;
 
-  ComplexMatrix extract_n (octave_idx_type r1, octave_idx_type c1, octave_idx_type nr, octave_idx_type nc) const;
+  ComplexMatrix extract_n (octave_idx_type r1, octave_idx_type c1,
+                           octave_idx_type nr, octave_idx_type nc) const;
 
   // extract row or column i.
 
@@ -186,7 +199,8 @@
 
   ComplexDET determinant (void) const;
   ComplexDET determinant (octave_idx_type& info) const;
-  ComplexDET determinant (octave_idx_type& info, double& rcon, int calc_cond = 1) const;
+  ComplexDET determinant (octave_idx_type& info, double& rcon,
+                          int calc_cond = 1) const;
   ComplexDET determinant (MatrixType &mattype, octave_idx_type& info,
                           double& rcon, int calc_cond = 1) const;
 
@@ -196,22 +210,23 @@
 private:
   // Upper triangular matrix solvers
   ComplexMatrix utsolve (MatrixType &typ, const ComplexMatrix& b,
-                  octave_idx_type& info, double& rcon,
-                  solve_singularity_handler sing_handler,
-                  bool calc_cond = false,
-                  blas_trans_type transt = blas_no_trans) const;
+                         octave_idx_type& info, double& rcon,
+                         solve_singularity_handler sing_handler,
+                         bool calc_cond = false,
+                         blas_trans_type transt = blas_no_trans) const;
 
   // Lower triangular matrix solvers
   ComplexMatrix ltsolve (MatrixType &typ, const ComplexMatrix& b,
-                  octave_idx_type& info, double& rcon,
-                  solve_singularity_handler sing_handler,
-                  bool calc_cond = false, blas_trans_type transt = blas_no_trans) const;
+                         octave_idx_type& info, double& rcon,
+                         solve_singularity_handler sing_handler,
+                         bool calc_cond = false,
+                         blas_trans_type transt = blas_no_trans) const;
 
   // Full matrix solvers (umfpack/cholesky)
   ComplexMatrix fsolve (MatrixType &typ, const ComplexMatrix& b,
-                 octave_idx_type& info, double& rcon,
-                 solve_singularity_handler sing_handler,
-                 bool calc_cond = false) const;
+                        octave_idx_type& info, double& rcon,
+                        solve_singularity_handler sing_handler,
+                        bool calc_cond = false) const;
 
 public:
   // Generic interface to solver with no probing of type
@@ -260,15 +275,18 @@
   // Generic interface to solver with probing of type
   ComplexMatrix solve (const Matrix& b) const;
   ComplexMatrix solve (const Matrix& b, octave_idx_type& info) const;
-  ComplexMatrix solve (const Matrix& b, octave_idx_type& info, double& rcon) const;
+  ComplexMatrix solve (const Matrix& b, octave_idx_type& info,
+                       double& rcon) const;
   ComplexMatrix solve (const Matrix& b, octave_idx_type& info, double& rcon,
                        solve_singularity_handler sing_handler,
                        blas_trans_type transt = blas_no_trans) const;
 
   ComplexMatrix solve (const ComplexMatrix& b) const;
   ComplexMatrix solve (const ComplexMatrix& b, octave_idx_type& info) const;
-  ComplexMatrix solve (const ComplexMatrix& b, octave_idx_type& info, double& rcon) const;
-  ComplexMatrix solve (const ComplexMatrix& b, octave_idx_type& info, double& rcon,
+  ComplexMatrix solve (const ComplexMatrix& b, octave_idx_type& info,
+                       double& rcon) const;
+  ComplexMatrix solve (const ComplexMatrix& b, octave_idx_type& info,
+                       double& rcon,
                        solve_singularity_handler sing_handler,
                        blas_trans_type transt = blas_no_trans) const;
 
@@ -276,16 +294,21 @@
   ComplexColumnVector solve (const ColumnVector& b, octave_idx_type& info) const;
   ComplexColumnVector solve (const ColumnVector& b, octave_idx_type& info,
                              double& rcon) const;
-  ComplexColumnVector solve (const ColumnVector& b, octave_idx_type& info, double& rcon,
+  ComplexColumnVector solve (const ColumnVector& b, octave_idx_type& info,
+                             double& rcon,
                              solve_singularity_handler sing_handler,
                              blas_trans_type transt = blas_no_trans) const;
 
   ComplexColumnVector solve (const ComplexColumnVector& b) const;
-  ComplexColumnVector solve (const ComplexColumnVector& b, octave_idx_type& info) const;
-  ComplexColumnVector solve (const ComplexColumnVector& b, octave_idx_type& info,
+  ComplexColumnVector solve (const ComplexColumnVector& b,
+                             octave_idx_type& info) const;
+  ComplexColumnVector solve (const ComplexColumnVector& b,
+                             octave_idx_type& info,
                              double& rcon) const;
-  ComplexColumnVector solve (const ComplexColumnVector& b, octave_idx_type& info,
-                             double& rcon, solve_singularity_handler sing_handler,
+  ComplexColumnVector solve (const ComplexColumnVector& b,
+                             octave_idx_type& info,
+                             double& rcon,
+                             solve_singularity_handler sing_handler,
                              blas_trans_type transt = blas_no_trans) const;
 
   ComplexMatrix lssolve (const Matrix& b) const;
@@ -376,8 +399,10 @@
 
   // i/o
 
-  friend OCTAVE_API std::ostream& operator << (std::ostream& os, const ComplexMatrix& a);
-  friend OCTAVE_API std::istream& operator >> (std::istream& is, ComplexMatrix& a);
+  friend OCTAVE_API std::ostream& operator << (std::ostream& os,
+                                               const ComplexMatrix& a);
+  friend OCTAVE_API std::istream& operator >> (std::istream& is,
+                                               ComplexMatrix& a);
 };
 
 extern OCTAVE_API ComplexMatrix conj (const ComplexMatrix& a);
@@ -404,17 +429,22 @@
        blas_trans_type transa = blas_no_trans,
        blas_trans_type transb = blas_no_trans);
 
-extern OCTAVE_API ComplexMatrix operator * (const Matrix&,        const ComplexMatrix&);
-extern OCTAVE_API ComplexMatrix operator * (const ComplexMatrix&, const Matrix&);
-extern OCTAVE_API ComplexMatrix operator * (const ComplexMatrix&, const ComplexMatrix&);
+extern OCTAVE_API ComplexMatrix operator * (const Matrix&,
+                                            const ComplexMatrix&);
+extern OCTAVE_API ComplexMatrix operator * (const ComplexMatrix&,
+                                            const Matrix&);
+extern OCTAVE_API ComplexMatrix operator * (const ComplexMatrix&,
+                                            const ComplexMatrix&);
 
 extern OCTAVE_API ComplexMatrix min (const Complex& c, const ComplexMatrix& m);
 extern OCTAVE_API ComplexMatrix min (const ComplexMatrix& m, const Complex& c);
-extern OCTAVE_API ComplexMatrix min (const ComplexMatrix& a, const ComplexMatrix& b);
+extern OCTAVE_API ComplexMatrix min (const ComplexMatrix& a,
+                                     const ComplexMatrix& b);
 
 extern OCTAVE_API ComplexMatrix max (const Complex& c, const ComplexMatrix& m);
 extern OCTAVE_API ComplexMatrix max (const ComplexMatrix& m, const Complex& c);
-extern OCTAVE_API ComplexMatrix max (const ComplexMatrix& a, const ComplexMatrix& b);
+extern OCTAVE_API ComplexMatrix max (const ComplexMatrix& a,
+                                     const ComplexMatrix& b);
 
 extern OCTAVE_API ComplexMatrix linspace (const ComplexColumnVector& x1,
                                           const ComplexColumnVector& x2,

--- a/liboctave/array/CNDArray.cc	Sat Oct 26 23:20:30 2013 +0200
+++ b/liboctave/array/CNDArray.cc	Sat Oct 26 18:57:05 2013 -0700
@@ -111,7 +111,7 @@
   // Need to be careful here about the distance between fft's
   for (octave_idx_type k = 0; k < nloop; k++)
     octave_fftw::ifft (in + k * stride * n, out + k * stride * n,
-                      n, howmany, stride, dist);
+                       n, howmany, stride, dist);
 
   return retval;
 }
@@ -293,7 +293,7 @@
 
           for (octave_idx_type i = 0; i < npts; i++)
             retval((i + k*npts)*stride + j*dist) = tmp[i] /
-              static_cast<double> (npts);
+                                                   static_cast<double> (npts);
         }
     }
 
@@ -386,8 +386,8 @@
               F77_FUNC (zfftb, ZFFTB) (npts, prow, pwsave);
 
               for (octave_idx_type l = 0; l < npts; l++)
-                retval((l + k*npts)*stride + j*dist) = prow[l] /
-                  static_cast<double> (npts);
+                retval((l + k*npts)*stride + j*dist) =
+                  prow[l] / static_cast<double> (npts);
             }
         }
 
@@ -481,8 +481,8 @@
               F77_FUNC (zfftb, ZFFTB) (npts, prow, pwsave);
 
               for (octave_idx_type l = 0; l < npts; l++)
-                retval((l + k*npts)*stride + j*dist) = prow[l] /
-                  static_cast<double> (npts);
+                retval((l + k*npts)*stride + j*dist) =
+                  prow[l] / static_cast<double> (npts);
             }
         }
 
@@ -505,7 +505,7 @@
   return do_mx_unary_op<bool, Complex> (*this, mx_inline_not);
 }
 
-// FIXME -- this is not quite the right thing.
+// FIXME: this is not quite the right thing.
 
 bool
 ComplexNDArray::any_element_is_nan (void) const
@@ -642,7 +642,8 @@
 }
 
 ComplexNDArray
-ComplexNDArray::concat (const ComplexNDArray& rb, const Array<octave_idx_type>& ra_idx)
+ComplexNDArray::concat (const ComplexNDArray& rb,
+                        const Array<octave_idx_type>& ra_idx)
 {
   if (rb.numel () > 0)
     insert (rb, ra_idx);
@@ -798,14 +799,16 @@
 }
 
 ComplexNDArray&
-ComplexNDArray::insert (const ComplexNDArray& a, octave_idx_type r, octave_idx_type c)
+ComplexNDArray::insert (const ComplexNDArray& a,
+                        octave_idx_type r, octave_idx_type c)
 {
   Array<Complex>::insert (a, r, c);
   return *this;
 }
 
 ComplexNDArray&
-ComplexNDArray::insert (const ComplexNDArray& a, const Array<octave_idx_type>& ra_idx)
+ComplexNDArray::insert (const ComplexNDArray& a,
+                        const Array<octave_idx_type>& ra_idx)
 {
   Array<Complex>::insert (a, ra_idx);
   return *this;
@@ -817,7 +820,7 @@
   ComplexMatrix retval;
 
   if (ndims () == 2)
-      retval = ComplexMatrix (Array<Complex> (*this));
+    retval = ComplexMatrix (Array<Complex> (*this));
   else
     (*current_liboctave_error_handler)
       ("invalid conversion of ComplexNDArray to ComplexMatrix");
@@ -876,16 +879,16 @@
     {
       Complex tmp;
       for (octave_idx_type i = 0; i < nel; i++)
-          {
-            tmp = octave_read_value<Complex> (is);
-            if (is)
-              a.elem (i) = tmp;
-            else
-              goto done;
-          }
+        {
+          tmp = octave_read_value<Complex> (is);
+          if (is)
+            a.elem (i) = tmp;
+          else
+            goto done;
+        }
     }
 
- done:
+done:
 
   return is;
 }

--- a/liboctave/array/CNDArray.h	Sat Oct 26 23:20:30 2013 +0200
+++ b/liboctave/array/CNDArray.h	Sat Oct 26 18:57:05 2013 -0700
@@ -58,16 +58,16 @@
   ComplexNDArray (const charNDArray&);
 
   ComplexNDArray& operator = (const ComplexNDArray& a)
-    {
-      MArray<Complex>::operator = (a);
-      return *this;
-    }
+  {
+    MArray<Complex>::operator = (a);
+    return *this;
+  }
 
   // unary operations
 
   boolNDArray operator ! (void) const;
 
-  // FIXME -- this is not quite the right thing.
+  // FIXME: this is not quite the right thing.
 
   bool any_element_is_nan (void) const;
   bool any_element_is_inf_or_nan (void) const;
@@ -84,8 +84,10 @@
   ComplexNDArray sum (int dim = -1) const;
   ComplexNDArray xsum (int dim = -1) const;
   ComplexNDArray sumsq (int dim = -1) const;
-  ComplexNDArray concat (const ComplexNDArray& rb, const Array<octave_idx_type>& ra_idx);
-  ComplexNDArray concat (const NDArray& rb, const Array<octave_idx_type>& ra_idx);
+  ComplexNDArray concat (const ComplexNDArray& rb,
+                         const Array<octave_idx_type>& ra_idx);
+  ComplexNDArray concat (const NDArray& rb,
+                         const Array<octave_idx_type>& ra_idx);
 
   ComplexNDArray max (int dim = -1) const;
   ComplexNDArray max (Array<octave_idx_type>& index, int dim = -1) const;
@@ -99,9 +101,12 @@
 
   ComplexNDArray diff (octave_idx_type order = 1, int dim = -1) const;
 
-  ComplexNDArray& insert (const NDArray& a, octave_idx_type r, octave_idx_type c);
-  ComplexNDArray& insert (const ComplexNDArray& a, octave_idx_type r, octave_idx_type c);
-  ComplexNDArray& insert (const ComplexNDArray& a, const Array<octave_idx_type>& ra_idx);
+  ComplexNDArray& insert (const NDArray& a,
+                          octave_idx_type r, octave_idx_type c);
+  ComplexNDArray& insert (const ComplexNDArray& a,
+                          octave_idx_type r, octave_idx_type c);
+  ComplexNDArray& insert (const ComplexNDArray& a,
+                          const Array<octave_idx_type>& ra_idx);
 
   NDArray abs (void) const;
   boolNDArray isnan (void) const;
@@ -128,12 +133,14 @@
                                int start_dimension = 0);
 
   static octave_idx_type compute_index (Array<octave_idx_type>& ra_idx,
-                            const dim_vector& dimensions);
+                                        const dim_vector& dimensions);
 
   // i/o
 
-  friend OCTAVE_API std::ostream& operator << (std::ostream& os, const ComplexNDArray& a);
-  friend OCTAVE_API std::istream& operator >> (std::istream& is, ComplexNDArray& a);
+  friend OCTAVE_API std::ostream& operator << (std::ostream& os,
+                                               const ComplexNDArray& a);
+  friend OCTAVE_API std::istream& operator >> (std::istream& is,
+                                               ComplexNDArray& a);
 
   //  bool all_elements_are_real (void) const;
   //  bool all_integers (double& max_val, double& min_val) const;
@@ -143,10 +150,10 @@
   ComplexNDArray diag (octave_idx_type m, octave_idx_type n) const;
 
   ComplexNDArray& changesign (void)
-    {
-      MArray<Complex>::changesign ();
-      return *this;
-    }
+  {
+    MArray<Complex>::changesign ();
+    return *this;
+  }
 
 };
 

--- a/liboctave/array/CRowVector.cc	Sat Oct 26 23:20:30 2013 +0200
+++ b/liboctave/array/CRowVector.cc	Sat Oct 26 18:57:05 2013 -0700
@@ -174,7 +174,8 @@
 }
 
 ComplexRowVector&
-ComplexRowVector::fill (const Complex& val, octave_idx_type c1, octave_idx_type c2)
+ComplexRowVector::fill (const Complex& val,
+                        octave_idx_type c1, octave_idx_type c2)
 {
   octave_idx_type len = length ();
 

--- a/liboctave/array/CRowVector.h	Sat Oct 26 23:20:30 2013 +0200
+++ b/liboctave/array/CRowVector.h	Sat Oct 26 18:57:05 2013 -0700
@@ -32,11 +32,11 @@
 OCTAVE_API
 ComplexRowVector : public MArray<Complex>
 {
-friend class ComplexColumnVector;
+  friend class ComplexColumnVector;
 
 public:
 
- ComplexRowVector (void) : MArray<Complex> (dim_vector (1, 0)) { }
+  ComplexRowVector (void) : MArray<Complex> (dim_vector (1, 0)) { }
 
   explicit ComplexRowVector (octave_idx_type n)
     : MArray<Complex> (dim_vector (1, n)) { }
@@ -57,10 +57,10 @@
   explicit ComplexRowVector (const RowVector& a) : MArray<Complex> (a) { }
 
   ComplexRowVector& operator = (const ComplexRowVector& a)
-    {
-      MArray<Complex>::operator = (a);
-      return *this;
-    }
+  {
+    MArray<Complex>::operator = (a);
+    return *this;
+  }
 
   bool operator == (const ComplexRowVector& a) const;
   bool operator != (const ComplexRowVector& a) const;
@@ -73,7 +73,8 @@
   ComplexRowVector& fill (double val);
   ComplexRowVector& fill (const Complex& val);
   ComplexRowVector& fill (double val, octave_idx_type c1, octave_idx_type c2);
-  ComplexRowVector& fill (const Complex& val, octave_idx_type c1, octave_idx_type c2);
+  ComplexRowVector& fill (const Complex& val,
+                          octave_idx_type c1, octave_idx_type c2);
 
   ComplexRowVector append (const RowVector& a) const;
   ComplexRowVector append (const ComplexRowVector& a) const;
@@ -109,7 +110,8 @@
 
   // i/o
 
-  friend std::ostream& operator << (std::ostream& os, const ComplexRowVector& a);
+  friend std::ostream& operator << (std::ostream& os,
+                                    const ComplexRowVector& a);
   friend std::istream& operator >> (std::istream& is, ComplexRowVector& a);
 
   void resize (octave_idx_type n, const Complex& rfv = Complex (0))
@@ -118,19 +120,22 @@
   }
 
   void clear (octave_idx_type n)
-    { Array<Complex>::clear (1, n); }
+  { Array<Complex>::clear (1, n); }
 
 };
 
 // row vector by column vector -> scalar
 
-Complex OCTAVE_API operator * (const ComplexRowVector& a, const ColumnVector& b);
+Complex OCTAVE_API operator * (const ComplexRowVector& a,
+                               const ColumnVector& b);
 
-Complex OCTAVE_API operator * (const ComplexRowVector& a, const ComplexColumnVector& b);
+Complex OCTAVE_API operator * (const ComplexRowVector& a,
+                               const ComplexColumnVector& b);
 
 // other operations
 
-OCTAVE_API ComplexRowVector linspace (const Complex& x1, const Complex& x2, octave_idx_type n);
+OCTAVE_API ComplexRowVector linspace (const Complex& x1, const Complex& x2,
+                                      octave_idx_type n);
 
 MARRAY_FORWARD_DEFS (MArray, ComplexRowVector, Complex)
 

--- a/liboctave/array/CSparse.cc	Sat Oct 26 23:20:30 2013 +0200
+++ b/liboctave/array/CSparse.cc	Sat Oct 26 18:57:05 2013 -0700
@@ -189,7 +189,7 @@
 
   for (octave_idx_type i = 0; i < nc + 1; i++)
     if (cidx (i) != a.cidx (i))
-        return false;
+      return false;
 
   for (octave_idx_type i = 0; i < nz; i++)
     if (data (i) != a.data (i) || ridx (i) != a.ridx (i))
@@ -351,7 +351,7 @@
         for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
           if (found [ridx (i)] == -j)
             found [ridx (i)] = -j - 1;
-      
+
       for (octave_idx_type i = 0; i < nr; i++)
         if (found [i] > -nc && found [i] < 0)
           idx_arg.elem (i) = -found [i];
@@ -508,7 +508,7 @@
         for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
           if (found [ridx (i)] == -j)
             found [ridx (i)] = -j - 1;
-      
+
       for (octave_idx_type i = 0; i < nr; i++)
         if (found [i] > -nc && found [i] < 0)
           idx_arg.elem (i) = -found [i];
@@ -563,16 +563,16 @@
 
 /*
 
-%!assert (max (max (speye (65536) * 1i)), sparse (1i)) 
-%!assert (min (min (speye (65536) * 1i)), sparse (0)) 
-%!assert (size (max (sparse (8, 0), [], 1)), [1, 0]) 
-%!assert (size (max (sparse (8, 0), [], 2)), [8, 0]) 
-%!assert (size (max (sparse (0, 8), [], 1)), [0, 8]) 
-%!assert (size (max (sparse (0, 8), [], 2)), [0, 1]) 
-%!assert (size (min (sparse (8, 0), [], 1)), [1, 0]) 
-%!assert (size (min (sparse (8, 0), [], 2)), [8, 0]) 
-%!assert (size (min (sparse (0, 8), [], 1)), [0, 8]) 
-%!assert (size (min (sparse (0, 8), [], 2)), [0, 1]) 
+%!assert (max (max (speye (65536) * 1i)), sparse (1i))
+%!assert (min (min (speye (65536) * 1i)), sparse (0))
+%!assert (size (max (sparse (8, 0), [], 1)), [1, 0])
+%!assert (size (max (sparse (8, 0), [], 2)), [8, 0])
+%!assert (size (max (sparse (0, 8), [], 1)), [0, 8])
+%!assert (size (max (sparse (0, 8), [], 2)), [0, 1])
+%!assert (size (min (sparse (8, 0), [], 1)), [1, 0])
+%!assert (size (min (sparse (8, 0), [], 2)), [8, 0])
+%!assert (size (min (sparse (0, 8), [], 1)), [0, 8])
+%!assert (size (min (sparse (0, 8), [], 2)), [0, 1])
 
 */
 
@@ -610,28 +610,32 @@
 // destructive insert/delete/reorder operations
 
 SparseComplexMatrix&
-SparseComplexMatrix::insert (const SparseMatrix& a, octave_idx_type r, octave_idx_type c)
+SparseComplexMatrix::insert (const SparseMatrix& a,
+                             octave_idx_type r, octave_idx_type c)
 {
   SparseComplexMatrix tmp (a);
   return insert (tmp /*a*/, r, c);
 }
 
 SparseComplexMatrix&
-SparseComplexMatrix::insert (const SparseComplexMatrix& a, octave_idx_type r, octave_idx_type c)
+SparseComplexMatrix::insert (const SparseComplexMatrix& a,
+                             octave_idx_type r, octave_idx_type c)
 {
   MSparse<Complex>::insert (a, r, c);
   return *this;
 }
 
 SparseComplexMatrix&
-SparseComplexMatrix::insert (const SparseMatrix& a, const Array<octave_idx_type>& indx)
+SparseComplexMatrix::insert (const SparseMatrix& a,
+                             const Array<octave_idx_type>& indx)
 {
   SparseComplexMatrix tmp (a);
   return insert (tmp /*a*/, indx);
 }
 
 SparseComplexMatrix&
-SparseComplexMatrix::insert (const SparseComplexMatrix& a, const Array<octave_idx_type>& indx)
+SparseComplexMatrix::insert (const SparseComplexMatrix& a,
+                             const Array<octave_idx_type>& indx)
 {
   MSparse<Complex>::insert (a, indx);
   return *this;
@@ -648,7 +652,8 @@
 }
 
 SparseComplexMatrix
-SparseComplexMatrix::concat (const SparseMatrix& rb, const Array<octave_idx_type>& ra_idx)
+SparseComplexMatrix::concat (const SparseMatrix& rb,
+                             const Array<octave_idx_type>& ra_idx)
 {
   SparseComplexMatrix tmp (rb);
   if (rb.rows () > 0 && rb.cols () > 0)
@@ -742,8 +747,8 @@
 
 SparseComplexMatrix
 SparseComplexMatrix::dinverse (MatrixType &mattyp, octave_idx_type& info,
-                        double& rcond, const bool,
-                        const bool calccond) const
+                               double& rcond, const bool,
+                               const bool calccond) const
 {
   SparseComplexMatrix retval;
 
@@ -1068,7 +1073,7 @@
 
   return retval;
 
- inverse_singular:
+inverse_singular:
   return SparseComplexMatrix ();
 }
 
@@ -1103,7 +1108,8 @@
               double rcond2;
               SparseMatrix Q = fact.Q ();
               SparseComplexMatrix InvL = fact.L ().transpose ().
-                tinverse (tmp_typ, info, rcond2, true, false);
+                                         tinverse (tmp_typ, info, rcond2,
+                                                   true, false);
               ret = Q * InvL.hermitian () * InvL * Q.transpose ();
             }
           else
@@ -1126,9 +1132,11 @@
           rcond = fact.rcond ();
           double rcond2;
           SparseComplexMatrix InvL = fact.L ().transpose ().
-            tinverse (tmp_typ, info, rcond2, true, false);
+                                     tinverse (tmp_typ, info, rcond2,
+                                               true, false);
           SparseComplexMatrix InvU = fact.U ().
-            tinverse (tmp_typ, info, rcond2, true, false).transpose ();
+                                     tinverse (tmp_typ, info, rcond2,
+                                               true, false).transpose ();
           ret = fact.Pc ().transpose () * InvU * InvL * fact.Pr ();
         }
     }
@@ -1152,7 +1160,8 @@
 }
 
 ComplexDET
-SparseComplexMatrix::determinant (octave_idx_type& err, double& rcond, int) const
+SparseComplexMatrix::determinant (octave_idx_type& err, double& rcond,
+                                  int) const
 {
   ComplexDET retval;
 #ifdef HAVE_UMFPACK
@@ -1206,8 +1215,8 @@
       Matrix Info (1, UMFPACK_INFO);
       double *info = Info.fortran_vec ();
       int status = UMFPACK_ZNAME (qsymbolic)
-        (nr, nc, Ap, Ai, reinterpret_cast<const double *> (Ax), 0,
-         0, &Symbolic, control, info);
+                   (nr, nc, Ap, Ai, reinterpret_cast<const double *> (Ax), 0,
+                    0, &Symbolic, control, info);
 
       if (status < 0)
         {
@@ -1217,7 +1226,7 @@
           UMFPACK_ZNAME (report_status) (control, status);
           UMFPACK_ZNAME (report_info) (control, info);
 
-          UMFPACK_ZNAME (free_symbolic) (&Symbolic) ;
+          UMFPACK_ZNAME (free_symbolic) (&Symbolic);
         }
       else
         {
@@ -1227,8 +1236,8 @@
           status
             = UMFPACK_ZNAME (numeric) (Ap, Ai,
                                        reinterpret_cast<const double *> (Ax),
-                                       0, Symbolic, &Numeric, control, info) ;
-          UMFPACK_ZNAME (free_symbolic) (&Symbolic) ;
+                                       0, Symbolic, &Numeric, control, info);
+          UMFPACK_ZNAME (free_symbolic) (&Symbolic);
 
           rcond = Info (UMFPACK_RCOND);
 
@@ -1302,8 +1311,8 @@
           retval.resize (nc, b.cols (), Complex (0.,0.));
           if (typ == MatrixType::Diagonal)
             for (octave_idx_type j = 0; j < b.cols (); j++)
-                for (octave_idx_type i = 0; i < nm; i++)
-                  retval(i,j) = b(i,j) / data (i);
+              for (octave_idx_type i = 0; i < nm; i++)
+                retval(i,j) = b(i,j) / data (i);
           else
             for (octave_idx_type j = 0; j < b.cols (); j++)
               for (octave_idx_type k = 0; k < nc; k++)
@@ -3899,7 +3908,7 @@
             rcond = 1.;
         }
       else if (typ != MatrixType::Tridiagonal_Hermitian)
-               (*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
 
   return retval;
@@ -4439,10 +4448,10 @@
                   double *piz = iz.fortran_vec ();
 
                   F77_XFCN (zpbcon, ZPBCON,
-                    (F77_CONST_CHAR_ARG2 (&job, 1),
-                     nr, n_lower, tmp_data, ldm,
-                     anorm, rcond, pz, piz, err
-                     F77_CHAR_ARG_LEN (1)));
+                            (F77_CONST_CHAR_ARG2 (&job, 1),
+                             nr, n_lower, tmp_data, ldm,
+                             anorm, rcond, pz, piz, err
+                             F77_CHAR_ARG_LEN (1)));
 
                   if (err != 0)
                     err = -2;
@@ -4560,12 +4569,12 @@
                   double *piz = iz.fortran_vec ();
 
                   F77_XFCN (zgbcon, ZGBCON,
-                    (F77_CONST_CHAR_ARG2 (&job, 1),
-                     nc, n_lower, n_upper, tmp_data, ldm, pipvt,
-                     anorm, rcond, pz, piz, err
-                     F77_CHAR_ARG_LEN (1)));
-
-                   if (err != 0)
+                            (F77_CONST_CHAR_ARG2 (&job, 1),
+                             nc, n_lower, n_upper, tmp_data, ldm, pipvt,
+                             anorm, rcond, pz, piz, err
+                             F77_CHAR_ARG_LEN (1)));
+
+                  if (err != 0)
                     err = -2;
 
                   volatile double rcond_plus_one = rcond + 1.0;
@@ -4686,10 +4695,10 @@
                   double *piz = iz.fortran_vec ();
 
                   F77_XFCN (zpbcon, ZPBCON,
-                    (F77_CONST_CHAR_ARG2 (&job, 1),
-                     nr, n_lower, tmp_data, ldm,
-                     anorm, rcond, pz, piz, err
-                     F77_CHAR_ARG_LEN (1)));
+                            (F77_CONST_CHAR_ARG2 (&job, 1),
+                             nr, n_lower, tmp_data, ldm,
+                             anorm, rcond, pz, piz, err
+                             F77_CHAR_ARG_LEN (1)));
 
                   if (err != 0)
                     err = -2;
@@ -4755,7 +4764,7 @@
                                 {
                                   // Resize the sparse matrix
                                   octave_idx_type sz = x_nz *
-                                    (b_nc - j) / b_nc;
+                                                       (b_nc - j) / b_nc;
                                   sz = (sz > 10 ? sz : 10) + x_nz;
                                   retval.change_capacity (sz);
                                   x_nz = sz;
@@ -4822,8 +4831,8 @@
 
               if (sing_handler)
                 {
-                sing_handler (rcond);
-                mattype.mark_as_rectangular ();
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
                 }
               else
                 (*current_liboctave_error_handler)
@@ -4841,12 +4850,12 @@
                   double *piz = iz.fortran_vec ();
 
                   F77_XFCN (zgbcon, ZGBCON,
-                    (F77_CONST_CHAR_ARG2 (&job, 1),
-                     nc, n_lower, n_upper, tmp_data, ldm, pipvt,
-                     anorm, rcond, pz, piz, err
-                     F77_CHAR_ARG_LEN (1)));
-
-                   if (err != 0)
+                            (F77_CONST_CHAR_ARG2 (&job, 1),
+                             nc, n_lower, n_upper, tmp_data, ldm, pipvt,
+                             anorm, rcond, pz, piz, err
+                             F77_CHAR_ARG_LEN (1)));
+
+                  if (err != 0)
                     err = -2;
 
                   volatile double rcond_plus_one = rcond + 1.0;
@@ -5006,10 +5015,10 @@
                   double *piz = iz.fortran_vec ();
 
                   F77_XFCN (zpbcon, ZPBCON,
-                    (F77_CONST_CHAR_ARG2 (&job, 1),
-                     nr, n_lower, tmp_data, ldm,
-                     anorm, rcond, pz, piz, err
-                     F77_CHAR_ARG_LEN (1)));
+                            (F77_CONST_CHAR_ARG2 (&job, 1),
+                             nr, n_lower, tmp_data, ldm,
+                             anorm, rcond, pz, piz, err
+                             F77_CHAR_ARG_LEN (1)));
 
                   if (err != 0)
                     err = -2;
@@ -5125,12 +5134,12 @@
                   double *piz = iz.fortran_vec ();
 
                   F77_XFCN (zgbcon, ZGBCON,
-                    (F77_CONST_CHAR_ARG2 (&job, 1),
-                     nc, n_lower, n_upper, tmp_data, ldm, pipvt,
-                     anorm, rcond, pz, piz, err
-                     F77_CHAR_ARG_LEN (1)));
-
-                   if (err != 0)
+                            (F77_CONST_CHAR_ARG2 (&job, 1),
+                             nc, n_lower, n_upper, tmp_data, ldm, pipvt,
+                             anorm, rcond, pz, piz, err
+                             F77_CHAR_ARG_LEN (1)));
+
+                  if (err != 0)
                     err = -2;
 
                   volatile double rcond_plus_one = rcond + 1.0;
@@ -5253,10 +5262,10 @@
                   double *piz = iz.fortran_vec ();
 
                   F77_XFCN (zpbcon, ZPBCON,
-                    (F77_CONST_CHAR_ARG2 (&job, 1),
-                     nr, n_lower, tmp_data, ldm,
-                     anorm, rcond, pz, piz, err
-                     F77_CHAR_ARG_LEN (1)));
+                            (F77_CONST_CHAR_ARG2 (&job, 1),
+                             nr, n_lower, tmp_data, ldm,
+                             anorm, rcond, pz, piz, err
+                             F77_CHAR_ARG_LEN (1)));
 
                   if (err != 0)
                     err = -2;
@@ -5413,12 +5422,12 @@
                   double *piz = iz.fortran_vec ();
 
                   F77_XFCN (zgbcon, ZGBCON,
-                    (F77_CONST_CHAR_ARG2 (&job, 1),
-                     nc, n_lower, n_upper, tmp_data, ldm, pipvt,
-                     anorm, rcond, pz, piz, err
-                     F77_CHAR_ARG_LEN (1)));
-
-                   if (err != 0)
+                            (F77_CONST_CHAR_ARG2 (&job, 1),
+                             nc, n_lower, n_upper, tmp_data, ldm, pipvt,
+                             anorm, rcond, pz, piz, err
+                             F77_CHAR_ARG_LEN (1)));
+
+                  if (err != 0)
                     err = -2;
 
                   volatile double rcond_plus_one = rcond + 1.0;
@@ -5549,8 +5558,8 @@
   Info = Matrix (1, UMFPACK_INFO);
   double *info = Info.fortran_vec ();
   int status = UMFPACK_ZNAME (qsymbolic) (nr, nc, Ap, Ai,
-                                     reinterpret_cast<const double *> (Ax),
-                                     0, 0, &Symbolic, control, info);
+                                          reinterpret_cast<const double *> (Ax),
+                                          0, 0, &Symbolic, control, info);
 
   if (status < 0)
     {
@@ -5561,16 +5570,16 @@
       UMFPACK_ZNAME (report_status) (control, status);
       UMFPACK_ZNAME (report_info) (control, info);
 
-      UMFPACK_ZNAME (free_symbolic) (&Symbolic) ;
+      UMFPACK_ZNAME (free_symbolic) (&Symbolic);
     }
   else
     {
       UMFPACK_ZNAME (report_symbolic) (Symbolic, control);
 
       status = UMFPACK_ZNAME (numeric) (Ap, Ai,
-                                   reinterpret_cast<const double *> (Ax), 0,
-                                   Symbolic, &Numeric, control, info) ;
-      UMFPACK_ZNAME (free_symbolic) (&Symbolic) ;
+                                        reinterpret_cast<const double *> (Ax),
+                                        0, Symbolic, &Numeric, control, info);
+      UMFPACK_ZNAME (free_symbolic) (&Symbolic);
 
       if (calc_cond)
         rcond = Info (UMFPACK_RCOND);
@@ -5594,19 +5603,19 @@
 
         }
       else if (status < 0)
-          {
-            (*current_liboctave_error_handler)
-              ("SparseComplexMatrix::solve numeric factorization failed");
-
-            UMFPACK_ZNAME (report_status) (control, status);
-            UMFPACK_ZNAME (report_info) (control, info);
-
-            err = -1;
-          }
-        else
-          {
-            UMFPACK_ZNAME (report_numeric) (Numeric, control);
-          }
+        {
+          (*current_liboctave_error_handler)
+            ("SparseComplexMatrix::solve numeric factorization failed");
+
+          UMFPACK_ZNAME (report_status) (control, status);
+          UMFPACK_ZNAME (report_info) (control, info);
+
+          err = -1;
+        }
+      else
+        {
+          UMFPACK_ZNAME (report_numeric) (Numeric, control);
+        }
     }
 
   if (err != 0)
@@ -5808,26 +5817,26 @@
                 {
 #ifdef UMFPACK_SEPARATE_SPLIT
                   status = UMFPACK_ZNAME (solve) (UMFPACK_A, Ap,
-                                             Ai,
-                                             reinterpret_cast<const double *> (Ax),
-                                             0,
-                                             reinterpret_cast<double *> (&Xx[iidx]),
-                                             0,
-                                             &Bx[iidx], Bz, Numeric,
-                                             control, info);
+                                                  Ai,
+                                                  reinterpret_cast<const double *> (Ax),
+                                                  0,
+                                                  reinterpret_cast<double *> (&Xx[iidx]),
+                                                  0,
+                                                  &Bx[iidx], Bz, Numeric,
+                                                  control, info);
 #else
                   for (octave_idx_type i = 0; i < b_nr; i++)
                     Bz[i] = b.elem (i, j);
 
                   status = UMFPACK_ZNAME (solve) (UMFPACK_A, Ap,
-                                             Ai,
-                                             reinterpret_cast<const double *> (Ax),
-                                             0,
-                                             reinterpret_cast<double *> (&Xx[iidx]),
-                                             0,
-                                             reinterpret_cast<const double *> (Bz),
-                                             0, Numeric,
-                                             control, info);
+                                                  Ai,
+                                                  reinterpret_cast<const double *> (Ax),
+                                                  0,
+                                                  reinterpret_cast<double *> (&Xx[iidx]),
+                                                  0,
+                                                  reinterpret_cast<const double *> (Bz),
+                                                  0, Numeric,
+                                                  control, info);
 #endif
 
                   if (status < 0)
@@ -6005,9 +6014,9 @@
               END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
 
               retval = SparseComplexMatrix
-                (static_cast<octave_idx_type>(X->nrow),
-                 static_cast<octave_idx_type>(X->ncol),
-                 static_cast<octave_idx_type>(X->nzmax));
+                       (static_cast<octave_idx_type>(X->nrow),
+                        static_cast<octave_idx_type>(X->ncol),
+                        static_cast<octave_idx_type>(X->nzmax));
               for (octave_idx_type j = 0;
                    j <= static_cast<octave_idx_type>(X->ncol); j++)
                 retval.xcidx (j) = static_cast<octave_idx_type *>(X->p)[j];
@@ -6079,26 +6088,26 @@
                     Bx[i] = b.elem (i, j);
 
                   status = UMFPACK_ZNAME (solve) (UMFPACK_A, Ap,
-                                             Ai,
-                                             reinterpret_cast<const double *> (Ax),
-                                             0,
-                                             reinterpret_cast<double *> (Xx),
-                                             0,
-                                             Bx, Bz, Numeric, control,
-                                             info);
+                                                  Ai,
+                                                  reinterpret_cast<const double *> (Ax),
+                                                  0,
+                                                  reinterpret_cast<double *> (Xx),
+                                                  0,
+                                                  Bx, Bz, Numeric, control,
+                                                  info);
 #else
                   for (octave_idx_type i = 0; i < b_nr; i++)
                     Bz[i] = b.elem (i, j);
 
                   status = UMFPACK_ZNAME (solve) (UMFPACK_A, Ap, Ai,
-                                             reinterpret_cast<const double *> (Ax),
-                                             0,
-                                             reinterpret_cast<double *> (Xx),
-                                             0,
-                                             reinterpret_cast<double *> (Bz),
-                                             0,
-                                             Numeric, control,
-                                             info);
+                                                  reinterpret_cast<const double *> (Ax),
+                                                  0,
+                                                  reinterpret_cast<double *> (Xx),
+                                                  0,
+                                                  reinterpret_cast<double *> (Bz),
+                                                  0,
+                                                  Numeric, control,
+                                                  info);
 #endif
                   if (status < 0)
                     {
@@ -6336,12 +6345,12 @@
                 {
                   status =
                     UMFPACK_ZNAME (solve) (UMFPACK_A, Ap, Ai,
-                                      reinterpret_cast<const double *> (Ax),
-                                      0,
-                                      reinterpret_cast<double *> (&Xx[iidx]),
-                                      0,
-                                      reinterpret_cast<const double *> (&Bx[iidx]),
-                                      0, Numeric, control, info);
+                                           reinterpret_cast<const double *> (Ax),
+                                           0,
+                                           reinterpret_cast<double *> (&Xx[iidx]),
+                                           0,
+                                           reinterpret_cast<const double *> (&Bx[iidx]),
+                                           0, Numeric, control, info);
 
                   if (status < 0)
                     {
@@ -6518,9 +6527,9 @@
               END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
 
               retval = SparseComplexMatrix
-                (static_cast<octave_idx_type>(X->nrow),
-                 static_cast<octave_idx_type>(X->ncol),
-                 static_cast<octave_idx_type>(X->nzmax));
+                       (static_cast<octave_idx_type>(X->nrow),
+                        static_cast<octave_idx_type>(X->ncol),
+                        static_cast<octave_idx_type>(X->nzmax));
               for (octave_idx_type j = 0;
                    j <= static_cast<octave_idx_type>(X->ncol); j++)
                 retval.xcidx (j) = static_cast<octave_idx_type *>(X->p)[j];
@@ -6583,13 +6592,13 @@
                     Bx[i] = b (i,j);
 
                   status = UMFPACK_ZNAME (solve) (UMFPACK_A, Ap,
-                                             Ai,
-                                             reinterpret_cast<const double *> (Ax),
-                                             0,
-                                             reinterpret_cast<double *> (Xx),
-                                             0,
-                                             reinterpret_cast<double *> (Bx),
-                                             0, Numeric, control, info);
+                                                  Ai,
+                                                  reinterpret_cast<const double *> (Ax),
+                                                  0,
+                                                  reinterpret_cast<double *> (Xx),
+                                                  0,
+                                                  reinterpret_cast<double *> (Bx),
+                                                  0, Numeric, control, info);
 
                   if (status < 0)
                     {
@@ -6720,8 +6729,8 @@
 #ifdef USE_QRSOLVE
       retval = qrsolve (*this, b, err);
 #else
-      retval = dmsolve<ComplexMatrix, SparseComplexMatrix,
-        Matrix> (*this, b, err);
+      retval = dmsolve<ComplexMatrix, SparseComplexMatrix, Matrix>
+               (*this, b, err);
 #endif
     }
 
@@ -6738,7 +6747,7 @@
 
 SparseComplexMatrix
 SparseComplexMatrix::solve (MatrixType &mattype, const SparseMatrix& b,
-                     octave_idx_type& info) const
+                            octave_idx_type& info) const
 {
   double rcond;
   return solve (mattype, b, info, rcond, 0);
@@ -6746,7 +6755,7 @@
 
 SparseComplexMatrix
 SparseComplexMatrix::solve (MatrixType &mattype, const SparseMatrix& b,
-                     octave_idx_type& info, double& rcond) const
+                            octave_idx_type& info, double& rcond) const
 {
   return solve (mattype, b, info, rcond, 0);
 }
@@ -6788,8 +6797,8 @@
 #ifdef USE_QRSOLVE
       retval = qrsolve (*this, b, err);
 #else
-      retval = dmsolve<SparseComplexMatrix, SparseComplexMatrix,
-        SparseMatrix> (*this, b, err);
+      retval = dmsolve<SparseComplexMatrix, SparseComplexMatrix, SparseMatrix>
+               (*this, b, err);
 #endif
     }
 
@@ -6856,8 +6865,8 @@
 #ifdef USE_QRSOLVE
       retval = qrsolve (*this, b, err);
 #else
-      retval = dmsolve<ComplexMatrix, SparseComplexMatrix,
-        ComplexMatrix> (*this, b, err);
+      retval = dmsolve<ComplexMatrix, SparseComplexMatrix, ComplexMatrix>
+               (*this, b, err);
 #endif
     }
 
@@ -6926,7 +6935,7 @@
       retval = qrsolve (*this, b, err);
 #else
       retval = dmsolve<SparseComplexMatrix, SparseComplexMatrix,
-        SparseComplexMatrix> (*this, b, err);
+                       SparseComplexMatrix> (*this, b, err);
 #endif
     }
 
@@ -6961,7 +6970,8 @@
                             solve_singularity_handler sing_handler) const
 {
   Matrix tmp (b);
-  return solve (mattype, tmp, info, rcond, sing_handler).column (static_cast<octave_idx_type> (0));
+  return solve (mattype, tmp, info, rcond,
+                sing_handler).column (static_cast<octave_idx_type> (0));
 }
 
 ComplexColumnVector
@@ -6994,7 +7004,8 @@
                             solve_singularity_handler sing_handler) const
 {
   ComplexMatrix tmp (b);
-  return solve (mattype, tmp, info, rcond, sing_handler).column (static_cast<octave_idx_type> (0));
+  return solve (mattype, tmp, info, rcond,
+                sing_handler).column (static_cast<octave_idx_type> (0));
 }
 
 ComplexMatrix
@@ -7014,7 +7025,7 @@
 
 ComplexMatrix
 SparseComplexMatrix::solve (const Matrix& b, octave_idx_type& info,
-                     double& rcond) const
+                            double& rcond) const
 {
   return solve (b, info, rcond, 0);
 }
@@ -7038,7 +7049,7 @@
 
 SparseComplexMatrix
 SparseComplexMatrix::solve (const SparseMatrix& b,
-                     octave_idx_type& info) const
+                            octave_idx_type& info) const
 {
   double rcond;
   return solve (b, info, rcond, 0);
@@ -7046,15 +7057,15 @@
 
 SparseComplexMatrix
 SparseComplexMatrix::solve (const SparseMatrix& b,
-                     octave_idx_type& info, double& rcond) const
+                            octave_idx_type& info, double& rcond) const
 {
   return solve (b, info, rcond, 0);
 }
 
 SparseComplexMatrix
 SparseComplexMatrix::solve (const SparseMatrix& b,
-                     octave_idx_type& err, double& rcond,
-                     solve_singularity_handler sing_handler) const
+                            octave_idx_type& err, double& rcond,
+                            solve_singularity_handler sing_handler) const
 {
   MatrixType mattype (*this);
   return solve (mattype, b, err, rcond, sing_handler);
@@ -7070,15 +7081,15 @@
 
 ComplexMatrix
 SparseComplexMatrix::solve (const ComplexMatrix& b,
-                     octave_idx_type& info, double& rcond) const
+                            octave_idx_type& info, double& rcond) const
 {
   return solve (b, info, rcond, 0);
 }
 
 ComplexMatrix
 SparseComplexMatrix::solve (const ComplexMatrix& b,
-                     octave_idx_type& err, double& rcond,
-                     solve_singularity_handler sing_handler) const
+                            octave_idx_type& err, double& rcond,
+                            solve_singularity_handler sing_handler) const
 {
   MatrixType mattype (*this);
   return solve (mattype, b, err, rcond, sing_handler);
@@ -7094,7 +7105,7 @@
 
 SparseComplexMatrix
 SparseComplexMatrix::solve (const SparseComplexMatrix& b,
-                     octave_idx_type& info) const
+                            octave_idx_type& info) const
 {
   double rcond;
   return solve (b, info, rcond, 0);
@@ -7102,15 +7113,15 @@
 
 SparseComplexMatrix
 SparseComplexMatrix::solve (const SparseComplexMatrix& b,
-                     octave_idx_type& info, double& rcond) const
+                            octave_idx_type& info, double& rcond) const
 {
   return solve (b, info, rcond, 0);
 }
 
 SparseComplexMatrix
 SparseComplexMatrix::solve (const SparseComplexMatrix& b,
-                     octave_idx_type& err, double& rcond,
-                     solve_singularity_handler sing_handler) const
+                            octave_idx_type& err, double& rcond,
+                            solve_singularity_handler sing_handler) const
 {
   MatrixType mattype (*this);
   return solve (mattype, b, err, rcond, sing_handler);
@@ -7138,11 +7149,13 @@
 }
 
 ComplexColumnVector
-SparseComplexMatrix::solve (const ColumnVector& b, octave_idx_type& info, double& rcond,
+SparseComplexMatrix::solve (const ColumnVector& b, octave_idx_type& info,
+                            double& rcond,
                             solve_singularity_handler sing_handler) const
 {
   Matrix tmp (b);
-  return solve (tmp, info, rcond, sing_handler).column (static_cast<octave_idx_type> (0));
+  return solve (tmp, info, rcond,
+                sing_handler).column (static_cast<octave_idx_type> (0));
 }
 
 ComplexColumnVector
@@ -7154,7 +7167,8 @@
 }
 
 ComplexColumnVector
-SparseComplexMatrix::solve (const ComplexColumnVector& b, octave_idx_type& info) const
+SparseComplexMatrix::solve (const ComplexColumnVector& b,
+                            octave_idx_type& info) const
 {
   double rcond;
   return solve (b, info, rcond, 0);
@@ -7162,7 +7176,7 @@
 
 ComplexColumnVector
 SparseComplexMatrix::solve (const ComplexColumnVector& b, octave_idx_type& info,
-                     double& rcond) const
+                            double& rcond) const
 {
   return solve (b, info, rcond, 0);
 }
@@ -7173,7 +7187,8 @@
                             solve_singularity_handler sing_handler) const
 {
   ComplexMatrix tmp (b);
-  return solve (tmp, info, rcond, sing_handler).column (static_cast<octave_idx_type> (0));
+  return solve (tmp, info, rcond,
+                sing_handler).column (static_cast<octave_idx_type> (0));
 }
 
 // unary operations
@@ -7292,25 +7307,25 @@
 
   for (octave_idx_type i = 0; i < nel; i++)
     {
-        Complex val = data (i);
-
-        double r_val = std::real (val);
-        double i_val = std::imag (val);
-
-        if (r_val > max_val)
-          max_val = r_val;
-
-        if (i_val > max_val)
-          max_val = i_val;
-
-        if (r_val < min_val)
-          min_val = r_val;
-
-        if (i_val < min_val)
-          min_val = i_val;
-
-        if (D_NINT (r_val) != r_val || D_NINT (i_val) != i_val)
-          return false;
+      Complex val = data (i);
+
+      double r_val = std::real (val);
+      double i_val = std::imag (val);
+
+      if (r_val > max_val)
+        max_val = r_val;
+
+      if (i_val > max_val)
+        max_val = i_val;
+
+      if (r_val < min_val)
+        min_val = r_val;
+
+      if (i_val < min_val)
+        min_val = i_val;
+
+      if (D_NINT (r_val) != r_val || D_NINT (i_val) != i_val)
+        return false;
     }
 
   return true;
@@ -7322,8 +7337,7 @@
   return test_any (xtoo_large_for_float);
 }
 
-// FIXME Do these really belong here?  Maybe they should be
-// in a base class?
+// FIXME: Do these really belong here?  Maybe they should be in a base class?
 
 SparseBoolMatrix
 SparseComplexMatrix::all (int dim) const
@@ -7415,18 +7429,18 @@
 {
   octave_idx_type nc = a.cols ();
 
-   // add one to the printed indices to go from
-   //  zero-based to one-based arrays
-   for (octave_idx_type j = 0; j < nc; j++)
-     {
-       octave_quit ();
-       for (octave_idx_type i = a.cidx (j); i < a.cidx (j+1); i++)
-         {
-           os << a.ridx (i) + 1 << " "  << j + 1 << " ";
-           octave_write_complex (os, a.data (i));
-           os << "\n";
-         }
-     }
+  // add one to the printed indices to go from
+  //  zero-based to one-based arrays
+  for (octave_idx_type j = 0; j < nc; j++)
+    {
+      octave_quit ();
+      for (octave_idx_type i = a.cidx (j); i < a.cidx (j+1); i++)
+        {
+          os << a.ridx (i) + 1 << " "  << j + 1 << " ";
+          octave_write_complex (os, a.data (i));
+          os << "\n";
+        }
+    }
 
   return os;
 }
@@ -7627,8 +7641,7 @@
   return octinternal_do_mul_sm_pm (a, p);
 }
 
-// FIXME -- it would be nice to share code among the min/max
-// functions below.
+// FIXME: it would be nice to share code among the min/max functions below.
 
 #define EMPTY_RETURN_CHECK(T) \
   if (nr == 0 || nc == 0) \
@@ -7879,11 +7892,11 @@
 }
 
 SPARSE_SMS_CMP_OPS (SparseComplexMatrix, 0.0, real, Complex,
-                   0.0, real)
+                    0.0, real)
 SPARSE_SMS_BOOL_OPS (SparseComplexMatrix, Complex, 0.0)
 
 SPARSE_SSM_CMP_OPS (Complex, 0.0, real, SparseComplexMatrix,
-                   0.0, real)
+                    0.0, real)
 SPARSE_SSM_BOOL_OPS (Complex, SparseComplexMatrix, 0.0)
 
 SPARSE_SMSM_CMP_OPS (SparseComplexMatrix, 0.0, real, SparseComplexMatrix,