--- a/liboctave/numeric/gepbalance.cc	Wed Aug 17 10:37:57 2016 -0400
+++ b/liboctave/numeric/gepbalance.cc	Wed Aug 17 10:55:38 2016 -0400
@@ -38,282 +38,280 @@
 
 namespace octave
 {
-namespace math
-{
+  namespace math
+  {
+    template <>
+    octave_idx_type
+    gepbalance<Matrix>::init (const Matrix& a, const Matrix& b,
+                              const std::string& balance_job)
+    {
+      octave_idx_type n = a.cols ();
 
-template <>
-octave_idx_type
-gepbalance<Matrix>::init (const Matrix& a, const Matrix& b,
-                          const std::string& balance_job)
-{
-  octave_idx_type n = a.cols ();
+      if (a.rows () != n)
+        (*current_liboctave_error_handler) ("GEPBALANCE requires square matrix");
+
+      if (a.dims () != b.dims ())
+        octave::err_nonconformant ("GEPBALANCE", n, n, b.rows(), b.cols());
 
-  if (a.rows () != n)
-    (*current_liboctave_error_handler) ("GEPBALANCE requires square matrix");
+      octave_idx_type info;
+      octave_idx_type ilo;
+      octave_idx_type ihi;
 
-  if (a.dims () != b.dims ())
-    octave::err_nonconformant ("GEPBALANCE", n, n, b.rows(), b.cols());
+      OCTAVE_LOCAL_BUFFER (double, plscale, n);
+      OCTAVE_LOCAL_BUFFER (double, prscale, n);
+      OCTAVE_LOCAL_BUFFER (double, pwork, 6 * n);
 
-  octave_idx_type info;
-  octave_idx_type ilo;
-  octave_idx_type ihi;
+      balanced_mat = a;
+      double *p_balanced_mat = balanced_mat.fortran_vec ();
+      balanced_mat2 = b;
+      double *p_balanced_mat2 = balanced_mat2.fortran_vec ();
+
+      char job = balance_job[0];
 
-  OCTAVE_LOCAL_BUFFER (double, plscale, n);
-  OCTAVE_LOCAL_BUFFER (double, prscale, n);
-  OCTAVE_LOCAL_BUFFER (double, pwork, 6 * n);
+      F77_XFCN (dggbal, DGGBAL, (F77_CONST_CHAR_ARG2 (&job, 1),
+                                 n, p_balanced_mat, n, p_balanced_mat2,
+                                 n, ilo, ihi, plscale, prscale, pwork, info
+                                 F77_CHAR_ARG_LEN  (1)));
 
-  balanced_mat = a;
-  double *p_balanced_mat = balanced_mat.fortran_vec ();
-  balanced_mat2 = b;
-  double *p_balanced_mat2 = balanced_mat2.fortran_vec ();
+      balancing_mat = Matrix (n, n, 0.0);
+      balancing_mat2 = Matrix (n, n, 0.0);
+      for (octave_idx_type i = 0; i < n; i++)
+        {
+          octave_quit ();
+          balancing_mat.elem (i ,i) = 1.0;
+          balancing_mat2.elem (i ,i) = 1.0;
+        }
 
-  char job = balance_job[0];
+      double *p_balancing_mat = balancing_mat.fortran_vec ();
+      double *p_balancing_mat2 = balancing_mat2.fortran_vec ();
 
-  F77_XFCN (dggbal, DGGBAL, (F77_CONST_CHAR_ARG2 (&job, 1),
-                             n, p_balanced_mat, n, p_balanced_mat2,
-                             n, ilo, ihi, plscale, prscale, pwork, info
-                             F77_CHAR_ARG_LEN  (1)));
+      // first left
+      F77_XFCN (dggbak, DGGBAK, (F77_CONST_CHAR_ARG2 (&job, 1),
+                                 F77_CONST_CHAR_ARG2 ("L", 1),
+                                 n, ilo, ihi, plscale, prscale,
+                                 n, p_balancing_mat, n, info
+                                 F77_CHAR_ARG_LEN (1)
+                                 F77_CHAR_ARG_LEN (1)));
 
-  balancing_mat = Matrix (n, n, 0.0);
-  balancing_mat2 = Matrix (n, n, 0.0);
-  for (octave_idx_type i = 0; i < n; i++)
-    {
-      octave_quit ();
-      balancing_mat.elem (i ,i) = 1.0;
-      balancing_mat2.elem (i ,i) = 1.0;
+      // then right
+      F77_XFCN (dggbak, DGGBAK, (F77_CONST_CHAR_ARG2 (&job, 1),
+                                 F77_CONST_CHAR_ARG2 ("R", 1),
+                                 n, ilo, ihi, plscale, prscale,
+                                 n, p_balancing_mat2, n, info
+                                 F77_CHAR_ARG_LEN (1)
+                                 F77_CHAR_ARG_LEN (1)));
+
+      return info;
     }
 
-  double *p_balancing_mat = balancing_mat.fortran_vec ();
-  double *p_balancing_mat2 = balancing_mat2.fortran_vec ();
+    template <>
+    octave_idx_type
+    gepbalance<FloatMatrix>::init (const FloatMatrix& a, const FloatMatrix& b,
+                                   const std::string& balance_job)
+    {
+      octave_idx_type n = a.cols ();
 
-  // first left
-  F77_XFCN (dggbak, DGGBAK, (F77_CONST_CHAR_ARG2 (&job, 1),
-                             F77_CONST_CHAR_ARG2 ("L", 1),
-                             n, ilo, ihi, plscale, prscale,
-                             n, p_balancing_mat, n, info
-                             F77_CHAR_ARG_LEN (1)
-                             F77_CHAR_ARG_LEN (1)));
+      if (a.rows () != n)
+        (*current_liboctave_error_handler)
+          ("FloatGEPBALANCE requires square matrix");
+
+      if (a.dims () != b.dims ())
+        octave::err_nonconformant ("FloatGEPBALANCE", n, n, b.rows(), b.cols());
 
-  // then right
-  F77_XFCN (dggbak, DGGBAK, (F77_CONST_CHAR_ARG2 (&job, 1),
-                             F77_CONST_CHAR_ARG2 ("R", 1),
-                             n, ilo, ihi, plscale, prscale,
-                             n, p_balancing_mat2, n, info
-                             F77_CHAR_ARG_LEN (1)
-                             F77_CHAR_ARG_LEN (1)));
+      octave_idx_type info;
+      octave_idx_type ilo;
+      octave_idx_type ihi;
 
-  return info;
-}
+      OCTAVE_LOCAL_BUFFER (float, plscale, n);
+      OCTAVE_LOCAL_BUFFER (float, prscale, n);
+      OCTAVE_LOCAL_BUFFER (float, pwork, 6 * n);
 
-template <>
-octave_idx_type
-gepbalance<FloatMatrix>::init (const FloatMatrix& a, const FloatMatrix& b,
-                               const std::string& balance_job)
-{
-  octave_idx_type n = a.cols ();
+      balanced_mat = a;
+      float *p_balanced_mat = balanced_mat.fortran_vec ();
+      balanced_mat2 = b;
+      float *p_balanced_mat2 = balanced_mat2.fortran_vec ();
+
+      char job = balance_job[0];
 
-  if (a.rows () != n)
-    (*current_liboctave_error_handler)
-      ("FloatGEPBALANCE requires square matrix");
-
-  if (a.dims () != b.dims ())
-    octave::err_nonconformant ("FloatGEPBALANCE", n, n, b.rows(), b.cols());
+      F77_XFCN (sggbal, SGGBAL, (F77_CONST_CHAR_ARG2 (&job, 1),
+                                 n, p_balanced_mat, n, p_balanced_mat2,
+                                 n, ilo, ihi, plscale, prscale, pwork, info
+                                 F77_CHAR_ARG_LEN  (1)));
 
-  octave_idx_type info;
-  octave_idx_type ilo;
-  octave_idx_type ihi;
+      balancing_mat = FloatMatrix (n, n, 0.0);
+      balancing_mat2 = FloatMatrix (n, n, 0.0);
+      for (octave_idx_type i = 0; i < n; i++)
+        {
+          octave_quit ();
+          balancing_mat.elem (i ,i) = 1.0;
+          balancing_mat2.elem (i ,i) = 1.0;
+        }
 
-  OCTAVE_LOCAL_BUFFER (float, plscale, n);
-  OCTAVE_LOCAL_BUFFER (float, prscale, n);
-  OCTAVE_LOCAL_BUFFER (float, pwork, 6 * n);
+      float *p_balancing_mat = balancing_mat.fortran_vec ();
+      float *p_balancing_mat2 = balancing_mat2.fortran_vec ();
 
-  balanced_mat = a;
-  float *p_balanced_mat = balanced_mat.fortran_vec ();
-  balanced_mat2 = b;
-  float *p_balanced_mat2 = balanced_mat2.fortran_vec ();
-
-  char job = balance_job[0];
+      // first left
+      F77_XFCN (sggbak, SGGBAK, (F77_CONST_CHAR_ARG2 (&job, 1),
+                                 F77_CONST_CHAR_ARG2 ("L", 1),
+                                 n, ilo, ihi, plscale, prscale,
+                                 n, p_balancing_mat, n, info
+                                 F77_CHAR_ARG_LEN (1)
+                                 F77_CHAR_ARG_LEN (1)));
 
-  F77_XFCN (sggbal, SGGBAL, (F77_CONST_CHAR_ARG2 (&job, 1),
-                             n, p_balanced_mat, n, p_balanced_mat2,
-                             n, ilo, ihi, plscale, prscale, pwork, info
-                             F77_CHAR_ARG_LEN  (1)));
+      // then right
+      F77_XFCN (sggbak, SGGBAK, (F77_CONST_CHAR_ARG2 (&job, 1),
+                                 F77_CONST_CHAR_ARG2 ("R", 1),
+                                 n, ilo, ihi, plscale, prscale,
+                                 n, p_balancing_mat2, n, info
+                                 F77_CHAR_ARG_LEN (1)
+                                 F77_CHAR_ARG_LEN (1)));
 
-  balancing_mat = FloatMatrix (n, n, 0.0);
-  balancing_mat2 = FloatMatrix (n, n, 0.0);
-  for (octave_idx_type i = 0; i < n; i++)
-    {
-      octave_quit ();
-      balancing_mat.elem (i ,i) = 1.0;
-      balancing_mat2.elem (i ,i) = 1.0;
+      return info;
     }
 
-  float *p_balancing_mat = balancing_mat.fortran_vec ();
-  float *p_balancing_mat2 = balancing_mat2.fortran_vec ();
+    template <>
+    octave_idx_type
+    gepbalance<ComplexMatrix>::init (const ComplexMatrix& a,
+                                     const ComplexMatrix& b,
+                                     const std::string& balance_job)
+    {
+      octave_idx_type n = a.cols ();
 
-  // first left
-  F77_XFCN (sggbak, SGGBAK, (F77_CONST_CHAR_ARG2 (&job, 1),
-                             F77_CONST_CHAR_ARG2 ("L", 1),
-                             n, ilo, ihi, plscale, prscale,
-                             n, p_balancing_mat, n, info
-                             F77_CHAR_ARG_LEN (1)
-                             F77_CHAR_ARG_LEN (1)));
+      if (a.rows () != n)
+        (*current_liboctave_error_handler)
+          ("ComplexGEPBALANCE requires square matrix");
+
+      if (a.dims () != b.dims ())
+        octave::err_nonconformant ("ComplexGEPBALANCE", n, n, b.rows(), b.cols());
 
-  // then right
-  F77_XFCN (sggbak, SGGBAK, (F77_CONST_CHAR_ARG2 (&job, 1),
-                             F77_CONST_CHAR_ARG2 ("R", 1),
-                             n, ilo, ihi, plscale, prscale,
-                             n, p_balancing_mat2, n, info
-                             F77_CHAR_ARG_LEN (1)
-                             F77_CHAR_ARG_LEN (1)));
+      octave_idx_type info;
+      octave_idx_type ilo;
+      octave_idx_type ihi;
 
-  return info;
-}
+      OCTAVE_LOCAL_BUFFER (double, plscale, n);
+      OCTAVE_LOCAL_BUFFER (double, prscale,  n);
+      OCTAVE_LOCAL_BUFFER (double, pwork, 6 * n);
 
-template <>
-octave_idx_type
-gepbalance<ComplexMatrix>::init (const ComplexMatrix& a,
-                                 const ComplexMatrix& b,
-                                 const std::string& balance_job)
-{
-  octave_idx_type n = a.cols ();
+      balanced_mat = a;
+      Complex *p_balanced_mat = balanced_mat.fortran_vec ();
+      balanced_mat2 = b;
+      Complex *p_balanced_mat2 = balanced_mat2.fortran_vec ();
+
+      char job = balance_job[0];
 
-  if (a.rows () != n)
-    (*current_liboctave_error_handler)
-      ("ComplexGEPBALANCE requires square matrix");
-
-  if (a.dims () != b.dims ())
-    octave::err_nonconformant ("ComplexGEPBALANCE", n, n, b.rows(), b.cols());
+      F77_XFCN (zggbal, ZGGBAL, (F77_CONST_CHAR_ARG2 (&job, 1),
+                                 n, F77_DBLE_CMPLX_ARG (p_balanced_mat), n, F77_DBLE_CMPLX_ARG (p_balanced_mat2),
+                                 n, ilo, ihi, plscale, prscale, pwork, info
+                                 F77_CHAR_ARG_LEN (1)));
 
-  octave_idx_type info;
-  octave_idx_type ilo;
-  octave_idx_type ihi;
+      balancing_mat = Matrix (n, n, 0.0);
+      balancing_mat2 = Matrix (n, n, 0.0);
+      for (octave_idx_type i = 0; i < n; i++)
+        {
+          octave_quit ();
+          balancing_mat.elem (i ,i) = 1.0;
+          balancing_mat2.elem (i ,i) = 1.0;
+        }
 
-  OCTAVE_LOCAL_BUFFER (double, plscale, n);
-  OCTAVE_LOCAL_BUFFER (double, prscale,  n);
-  OCTAVE_LOCAL_BUFFER (double, pwork, 6 * n);
+      double *p_balancing_mat = balancing_mat.fortran_vec ();
+      double *p_balancing_mat2 = balancing_mat2.fortran_vec ();
 
-  balanced_mat = a;
-  Complex *p_balanced_mat = balanced_mat.fortran_vec ();
-  balanced_mat2 = b;
-  Complex *p_balanced_mat2 = balanced_mat2.fortran_vec ();
-
-  char job = balance_job[0];
+      // first left
+      F77_XFCN (dggbak, DGGBAK, (F77_CONST_CHAR_ARG2 (&job, 1),
+                                 F77_CONST_CHAR_ARG2 ("L", 1),
+                                 n, ilo, ihi, plscale, prscale,
+                                 n, p_balancing_mat, n, info
+                                 F77_CHAR_ARG_LEN (1)
+                                 F77_CHAR_ARG_LEN (1)));
 
-  F77_XFCN (zggbal, ZGGBAL, (F77_CONST_CHAR_ARG2 (&job, 1),
-                             n, F77_DBLE_CMPLX_ARG (p_balanced_mat), n, F77_DBLE_CMPLX_ARG (p_balanced_mat2),
-                             n, ilo, ihi, plscale, prscale, pwork, info
-                             F77_CHAR_ARG_LEN (1)));
+      // then right
+      F77_XFCN (dggbak, DGGBAK, (F77_CONST_CHAR_ARG2 (&job, 1),
+                                 F77_CONST_CHAR_ARG2 ("R", 1),
+                                 n, ilo, ihi, plscale, prscale,
+                                 n, p_balancing_mat2, n, info
+                                 F77_CHAR_ARG_LEN (1)
+                                 F77_CHAR_ARG_LEN (1)));
 
-  balancing_mat = Matrix (n, n, 0.0);
-  balancing_mat2 = Matrix (n, n, 0.0);
-  for (octave_idx_type i = 0; i < n; i++)
-    {
-      octave_quit ();
-      balancing_mat.elem (i ,i) = 1.0;
-      balancing_mat2.elem (i ,i) = 1.0;
+      return info;
     }
 
-  double *p_balancing_mat = balancing_mat.fortran_vec ();
-  double *p_balancing_mat2 = balancing_mat2.fortran_vec ();
+    template <>
+    octave_idx_type
+    gepbalance<FloatComplexMatrix>::init (const FloatComplexMatrix& a,
+                                          const FloatComplexMatrix& b,
+                                          const std::string& balance_job)
+    {
+      octave_idx_type n = a.cols ();
+
+      if (a.rows () != n)
+        {
+          (*current_liboctave_error_handler)
+            ("FloatComplexGEPBALANCE requires square matrix");
+          return -1;
+        }
 
-  // first left
-  F77_XFCN (dggbak, DGGBAK, (F77_CONST_CHAR_ARG2 (&job, 1),
-                             F77_CONST_CHAR_ARG2 ("L", 1),
-                             n, ilo, ihi, plscale, prscale,
-                             n, p_balancing_mat, n, info
-                             F77_CHAR_ARG_LEN (1)
-                             F77_CHAR_ARG_LEN (1)));
+      if (a.dims () != b.dims ())
+        octave::err_nonconformant ("FloatComplexGEPBALANCE", n, n, b.rows(), b.cols());
+
+      octave_idx_type info;
+      octave_idx_type ilo;
+      octave_idx_type ihi;
+
+      OCTAVE_LOCAL_BUFFER (float, plscale, n);
+      OCTAVE_LOCAL_BUFFER (float, prscale, n);
+      OCTAVE_LOCAL_BUFFER (float, pwork, 6 * n);
+
+      balanced_mat = a;
+      FloatComplex *p_balanced_mat = balanced_mat.fortran_vec ();
+      balanced_mat2 = b;
+      FloatComplex *p_balanced_mat2 = balanced_mat2.fortran_vec ();
+
+      char job = balance_job[0];
 
-  // then right
-  F77_XFCN (dggbak, DGGBAK, (F77_CONST_CHAR_ARG2 (&job, 1),
-                             F77_CONST_CHAR_ARG2 ("R", 1),
-                             n, ilo, ihi, plscale, prscale,
-                             n, p_balancing_mat2, n, info
-                             F77_CHAR_ARG_LEN (1)
-                             F77_CHAR_ARG_LEN (1)));
+      F77_XFCN (cggbal, CGGBAL, (F77_CONST_CHAR_ARG2 (&job, 1),
+                                 n, F77_CMPLX_ARG (p_balanced_mat), n, F77_CMPLX_ARG (p_balanced_mat2),
+                                 n, ilo, ihi, plscale, prscale, pwork, info
+                                 F77_CHAR_ARG_LEN (1)));
 
-  return info;
-}
+      balancing_mat = FloatMatrix (n, n, 0.0);
+      balancing_mat2 = FloatMatrix (n, n, 0.0);
+      for (octave_idx_type i = 0; i < n; i++)
+        {
+          octave_quit ();
+          balancing_mat.elem (i ,i) = 1.0;
+          balancing_mat2.elem (i ,i) = 1.0;
+        }
+
+      float *p_balancing_mat = balancing_mat.fortran_vec ();
+      float *p_balancing_mat2 = balancing_mat2.fortran_vec ();
 
-template <>
-octave_idx_type
-gepbalance<FloatComplexMatrix>::init (const FloatComplexMatrix& a,
-                                      const FloatComplexMatrix& b,
-                                      const std::string& balance_job)
-{
-  octave_idx_type n = a.cols ();
+      // first left
+      F77_XFCN (sggbak, SGGBAK, (F77_CONST_CHAR_ARG2 (&job, 1),
+                                 F77_CONST_CHAR_ARG2 ("L", 1),
+                                 n, ilo, ihi, plscale, prscale,
+                                 n, p_balancing_mat, n, info
+                                 F77_CHAR_ARG_LEN (1)
+                                 F77_CHAR_ARG_LEN (1)));
 
-  if (a.rows () != n)
-    {
-      (*current_liboctave_error_handler)
-        ("FloatComplexGEPBALANCE requires square matrix");
-      return -1;
+      // then right
+      F77_XFCN (sggbak, SGGBAK, (F77_CONST_CHAR_ARG2 (&job, 1),
+                                 F77_CONST_CHAR_ARG2 ("R", 1),
+                                 n, ilo, ihi, plscale, prscale,
+                                 n, p_balancing_mat2, n, info
+                                 F77_CHAR_ARG_LEN (1)
+                                 F77_CHAR_ARG_LEN (1)));
+
+      return info;
     }
 
-  if (a.dims () != b.dims ())
-    octave::err_nonconformant ("FloatComplexGEPBALANCE", n, n, b.rows(), b.cols());
-
-  octave_idx_type info;
-  octave_idx_type ilo;
-  octave_idx_type ihi;
-
-  OCTAVE_LOCAL_BUFFER (float, plscale, n);
-  OCTAVE_LOCAL_BUFFER (float, prscale, n);
-  OCTAVE_LOCAL_BUFFER (float, pwork, 6 * n);
-
-  balanced_mat = a;
-  FloatComplex *p_balanced_mat = balanced_mat.fortran_vec ();
-  balanced_mat2 = b;
-  FloatComplex *p_balanced_mat2 = balanced_mat2.fortran_vec ();
+    // Instantiations we need.
 
-  char job = balance_job[0];
-
-  F77_XFCN (cggbal, CGGBAL, (F77_CONST_CHAR_ARG2 (&job, 1),
-                             n, F77_CMPLX_ARG (p_balanced_mat), n, F77_CMPLX_ARG (p_balanced_mat2),
-                             n, ilo, ihi, plscale, prscale, pwork, info
-                             F77_CHAR_ARG_LEN (1)));
+    template class gepbalance<Matrix>;
 
-  balancing_mat = FloatMatrix (n, n, 0.0);
-  balancing_mat2 = FloatMatrix (n, n, 0.0);
-  for (octave_idx_type i = 0; i < n; i++)
-    {
-      octave_quit ();
-      balancing_mat.elem (i ,i) = 1.0;
-      balancing_mat2.elem (i ,i) = 1.0;
-    }
+    template class gepbalance<FloatMatrix>;
 
-  float *p_balancing_mat = balancing_mat.fortran_vec ();
-  float *p_balancing_mat2 = balancing_mat2.fortran_vec ();
-
-  // first left
-  F77_XFCN (sggbak, SGGBAK, (F77_CONST_CHAR_ARG2 (&job, 1),
-                             F77_CONST_CHAR_ARG2 ("L", 1),
-                             n, ilo, ihi, plscale, prscale,
-                             n, p_balancing_mat, n, info
-                             F77_CHAR_ARG_LEN (1)
-                             F77_CHAR_ARG_LEN (1)));
+    template class gepbalance<ComplexMatrix>;
 
-  // then right
-  F77_XFCN (sggbak, SGGBAK, (F77_CONST_CHAR_ARG2 (&job, 1),
-                             F77_CONST_CHAR_ARG2 ("R", 1),
-                             n, ilo, ihi, plscale, prscale,
-                             n, p_balancing_mat2, n, info
-                             F77_CHAR_ARG_LEN (1)
-                             F77_CHAR_ARG_LEN (1)));
-
-  return info;
+    template class gepbalance<FloatComplexMatrix>;
+  }
 }
-
-// Instantiations we need.
-
-template class gepbalance<Matrix>;
-
-template class gepbalance<FloatMatrix>;
-
-template class gepbalance<ComplexMatrix>;
-
-template class gepbalance<FloatComplexMatrix>;
-
-}
-}