--- a/liboctave/numeric/qrp.cc	Wed Aug 17 10:37:57 2016 -0400
+++ b/liboctave/numeric/qrp.cc	Wed Aug 17 10:55:38 2016 -0400
@@ -40,270 +40,268 @@
 
 namespace octave
 {
-namespace math
-{
-
-// Specialization.
-
-template <>
-void
-qrp<Matrix>::init (const Matrix& a, type qr_type)
-{
-  assert (qr_type != qr<Matrix>::raw);
+  namespace math
+  {
+    // Specialization.
 
-  octave_idx_type m = a.rows ();
-  octave_idx_type n = a.cols ();
-
-  octave_idx_type min_mn = m < n ? m : n;
-  OCTAVE_LOCAL_BUFFER (double, tau, min_mn);
-
-  octave_idx_type info = 0;
-
-  Matrix afact = a;
-  if (m > n && qr_type == qr<Matrix>::std)
-    afact.resize (m, m);
-
-  MArray<octave_idx_type> jpvt (dim_vector (n, 1), 0);
-
-  if (m > 0)
+    template <>
+    void
+    qrp<Matrix>::init (const Matrix& a, type qr_type)
     {
-      // workspace query.
-      double rlwork;
-      F77_XFCN (dgeqp3, DGEQP3, (m, n, afact.fortran_vec (),
-                                 m, jpvt.fortran_vec (), tau,
-                                 &rlwork, -1, info));
+      assert (qr_type != qr<Matrix>::raw);
+
+      octave_idx_type m = a.rows ();
+      octave_idx_type n = a.cols ();
+
+      octave_idx_type min_mn = m < n ? m : n;
+      OCTAVE_LOCAL_BUFFER (double, tau, min_mn);
+
+      octave_idx_type info = 0;
+
+      Matrix afact = a;
+      if (m > n && qr_type == qr<Matrix>::std)
+        afact.resize (m, m);
+
+      MArray<octave_idx_type> jpvt (dim_vector (n, 1), 0);
 
-      // allocate buffer and do the job.
-      octave_idx_type lwork = rlwork;
-      lwork = std::max (lwork, static_cast<octave_idx_type> (1));
-      OCTAVE_LOCAL_BUFFER (double, work, lwork);
-      F77_XFCN (dgeqp3, DGEQP3, (m, n, afact.fortran_vec (),
-                                 m, jpvt.fortran_vec (), tau,
-                                 work, lwork, info));
+      if (m > 0)
+        {
+          // workspace query.
+          double rlwork;
+          F77_XFCN (dgeqp3, DGEQP3, (m, n, afact.fortran_vec (),
+                                     m, jpvt.fortran_vec (), tau,
+                                     &rlwork, -1, info));
+
+          // allocate buffer and do the job.
+          octave_idx_type lwork = rlwork;
+          lwork = std::max (lwork, static_cast<octave_idx_type> (1));
+          OCTAVE_LOCAL_BUFFER (double, work, lwork);
+          F77_XFCN (dgeqp3, DGEQP3, (m, n, afact.fortran_vec (),
+                                     m, jpvt.fortran_vec (), tau,
+                                     work, lwork, info));
+        }
+      else
+        for (octave_idx_type i = 0; i < n; i++) jpvt(i) = i+1;
+
+      // Form Permutation matrix (if economy is requested, return the
+      // indices only!)
+
+      jpvt -= static_cast<octave_idx_type> (1);
+      p = PermMatrix (jpvt, true);
+
+      form (n, afact, tau, qr_type);
     }
-  else
-    for (octave_idx_type i = 0; i < n; i++) jpvt(i) = i+1;
 
-  // Form Permutation matrix (if economy is requested, return the
-  // indices only!)
-
-  jpvt -= static_cast<octave_idx_type> (1);
-  p = PermMatrix (jpvt, true);
-
-  form (n, afact, tau, qr_type);
-}
-
-template <>
-qrp<Matrix>::qrp (const Matrix& a, type qr_type)
-  : qr<Matrix> (), p ()
-{
-  init (a, qr_type);
-}
+    template <>
+    qrp<Matrix>::qrp (const Matrix& a, type qr_type)
+      : qr<Matrix> (), p ()
+    {
+      init (a, qr_type);
+    }
 
-template <>
-RowVector
-qrp<Matrix>::Pvec (void) const
-{
-  Array<double> pa (p.col_perm_vec ());
-  RowVector pv (MArray<double> (pa) + 1.0);
-  return pv;
-}
-
-template <>
-void
-qrp<FloatMatrix>::init (const FloatMatrix& a, type qr_type)
-{
-  assert (qr_type != qr<FloatMatrix>::raw);
+    template <>
+    RowVector
+    qrp<Matrix>::Pvec (void) const
+    {
+      Array<double> pa (p.col_perm_vec ());
+      RowVector pv (MArray<double> (pa) + 1.0);
+      return pv;
+    }
 
-  octave_idx_type m = a.rows ();
-  octave_idx_type n = a.cols ();
-
-  octave_idx_type min_mn = m < n ? m : n;
-  OCTAVE_LOCAL_BUFFER (float, tau, min_mn);
-
-  octave_idx_type info = 0;
-
-  FloatMatrix afact = a;
-  if (m > n && qr_type == qr<FloatMatrix>::std)
-    afact.resize (m, m);
-
-  MArray<octave_idx_type> jpvt (dim_vector (n, 1), 0);
-
-  if (m > 0)
+    template <>
+    void
+    qrp<FloatMatrix>::init (const FloatMatrix& a, type qr_type)
     {
-      // workspace query.
-      float rlwork;
-      F77_XFCN (sgeqp3, SGEQP3, (m, n, afact.fortran_vec (),
-                                 m, jpvt.fortran_vec (), tau,
-                                 &rlwork, -1, info));
+      assert (qr_type != qr<FloatMatrix>::raw);
+
+      octave_idx_type m = a.rows ();
+      octave_idx_type n = a.cols ();
+
+      octave_idx_type min_mn = m < n ? m : n;
+      OCTAVE_LOCAL_BUFFER (float, tau, min_mn);
+
+      octave_idx_type info = 0;
 
-      // allocate buffer and do the job.
-      octave_idx_type lwork = rlwork;
-      lwork = std::max (lwork, static_cast<octave_idx_type> (1));
-      OCTAVE_LOCAL_BUFFER (float, work, lwork);
-      F77_XFCN (sgeqp3, SGEQP3, (m, n, afact.fortran_vec (),
-                                 m, jpvt.fortran_vec (), tau,
-                                 work, lwork, info));
-    }
-  else
-    for (octave_idx_type i = 0; i < n; i++) jpvt(i) = i+1;
+      FloatMatrix afact = a;
+      if (m > n && qr_type == qr<FloatMatrix>::std)
+        afact.resize (m, m);
+
+      MArray<octave_idx_type> jpvt (dim_vector (n, 1), 0);
 
-  // Form Permutation matrix (if economy is requested, return the
-  // indices only!)
+      if (m > 0)
+        {
+          // workspace query.
+          float rlwork;
+          F77_XFCN (sgeqp3, SGEQP3, (m, n, afact.fortran_vec (),
+                                     m, jpvt.fortran_vec (), tau,
+                                     &rlwork, -1, info));
 
-  jpvt -= static_cast<octave_idx_type> (1);
-  p = PermMatrix (jpvt, true);
+          // allocate buffer and do the job.
+          octave_idx_type lwork = rlwork;
+          lwork = std::max (lwork, static_cast<octave_idx_type> (1));
+          OCTAVE_LOCAL_BUFFER (float, work, lwork);
+          F77_XFCN (sgeqp3, SGEQP3, (m, n, afact.fortran_vec (),
+                                     m, jpvt.fortran_vec (), tau,
+                                     work, lwork, info));
+        }
+      else
+        for (octave_idx_type i = 0; i < n; i++) jpvt(i) = i+1;
 
-  form (n, afact, tau, qr_type);
-}
+      // Form Permutation matrix (if economy is requested, return the
+      // indices only!)
+
+      jpvt -= static_cast<octave_idx_type> (1);
+      p = PermMatrix (jpvt, true);
 
-template <>
-qrp<FloatMatrix>::qrp (const FloatMatrix& a, type qr_type)
-  : qr<FloatMatrix> (), p ()
-{
-  init (a, qr_type);
-}
+      form (n, afact, tau, qr_type);
+    }
 
-template <>
-FloatRowVector
-qrp<FloatMatrix>::Pvec (void) const
-{
-  Array<float> pa (p.col_perm_vec ());
-  FloatRowVector pv (MArray<float> (pa) + 1.0f);
-  return pv;
-}
+    template <>
+    qrp<FloatMatrix>::qrp (const FloatMatrix& a, type qr_type)
+      : qr<FloatMatrix> (), p ()
+    {
+      init (a, qr_type);
+    }
+
+    template <>
+    FloatRowVector
+    qrp<FloatMatrix>::Pvec (void) const
+    {
+      Array<float> pa (p.col_perm_vec ());
+      FloatRowVector pv (MArray<float> (pa) + 1.0f);
+      return pv;
+    }
 
-template <>
-void
-qrp<ComplexMatrix>::init (const ComplexMatrix& a, type qr_type)
-{
-  assert (qr_type != qr<ComplexMatrix>::raw);
+    template <>
+    void
+    qrp<ComplexMatrix>::init (const ComplexMatrix& a, type qr_type)
+    {
+      assert (qr_type != qr<ComplexMatrix>::raw);
 
-  octave_idx_type m = a.rows ();
-  octave_idx_type n = a.cols ();
+      octave_idx_type m = a.rows ();
+      octave_idx_type n = a.cols ();
 
-  octave_idx_type min_mn = m < n ? m : n;
-  OCTAVE_LOCAL_BUFFER (Complex, tau, min_mn);
+      octave_idx_type min_mn = m < n ? m : n;
+      OCTAVE_LOCAL_BUFFER (Complex, tau, min_mn);
 
-  octave_idx_type info = 0;
+      octave_idx_type info = 0;
 
-  ComplexMatrix afact = a;
-  if (m > n && qr_type == qr<ComplexMatrix>::std)
-    afact.resize (m, m);
+      ComplexMatrix afact = a;
+      if (m > n && qr_type == qr<ComplexMatrix>::std)
+        afact.resize (m, m);
 
-  MArray<octave_idx_type> jpvt (dim_vector (n, 1), 0);
+      MArray<octave_idx_type> jpvt (dim_vector (n, 1), 0);
 
-  if (m > 0)
-    {
-      OCTAVE_LOCAL_BUFFER (double, rwork, 2*n);
+      if (m > 0)
+        {
+          OCTAVE_LOCAL_BUFFER (double, rwork, 2*n);
 
-      // workspace query.
-      Complex clwork;
-      F77_XFCN (zgeqp3, ZGEQP3, (m, n, F77_DBLE_CMPLX_ARG (afact.fortran_vec ()),
-                                 m, jpvt.fortran_vec (), F77_DBLE_CMPLX_ARG (tau),
-                                 F77_DBLE_CMPLX_ARG (&clwork), -1, rwork, info));
+          // workspace query.
+          Complex clwork;
+          F77_XFCN (zgeqp3, ZGEQP3, (m, n, F77_DBLE_CMPLX_ARG (afact.fortran_vec ()),
+                                     m, jpvt.fortran_vec (), F77_DBLE_CMPLX_ARG (tau),
+                                     F77_DBLE_CMPLX_ARG (&clwork), -1, rwork, info));
 
-      // allocate buffer and do the job.
-      octave_idx_type lwork = clwork.real ();
-      lwork = std::max (lwork, static_cast<octave_idx_type> (1));
-      OCTAVE_LOCAL_BUFFER (Complex, work, lwork);
-      F77_XFCN (zgeqp3, ZGEQP3, (m, n, F77_DBLE_CMPLX_ARG (afact.fortran_vec ()),
-                                 m, jpvt.fortran_vec (), F77_DBLE_CMPLX_ARG (tau),
-                                 F77_DBLE_CMPLX_ARG (work), lwork, rwork, info));
-    }
-  else
-    for (octave_idx_type i = 0; i < n; i++) jpvt(i) = i+1;
+          // allocate buffer and do the job.
+          octave_idx_type lwork = clwork.real ();
+          lwork = std::max (lwork, static_cast<octave_idx_type> (1));
+          OCTAVE_LOCAL_BUFFER (Complex, work, lwork);
+          F77_XFCN (zgeqp3, ZGEQP3, (m, n, F77_DBLE_CMPLX_ARG (afact.fortran_vec ()),
+                                     m, jpvt.fortran_vec (), F77_DBLE_CMPLX_ARG (tau),
+                                     F77_DBLE_CMPLX_ARG (work), lwork, rwork, info));
+        }
+      else
+        for (octave_idx_type i = 0; i < n; i++) jpvt(i) = i+1;
 
-  // Form Permutation matrix (if economy is requested, return the
-  // indices only!)
+      // Form Permutation matrix (if economy is requested, return the
+      // indices only!)
 
-  jpvt -= static_cast<octave_idx_type> (1);
-  p = PermMatrix (jpvt, true);
+      jpvt -= static_cast<octave_idx_type> (1);
+      p = PermMatrix (jpvt, true);
 
-  form (n, afact, tau, qr_type);
-}
+      form (n, afact, tau, qr_type);
+    }
 
-template <>
-qrp<ComplexMatrix>::qrp (const ComplexMatrix& a, type qr_type)
-  : qr<ComplexMatrix> (), p ()
-{
-  init (a, qr_type);
-}
+    template <>
+    qrp<ComplexMatrix>::qrp (const ComplexMatrix& a, type qr_type)
+      : qr<ComplexMatrix> (), p ()
+    {
+      init (a, qr_type);
+    }
 
-template <>
-RowVector
-qrp<ComplexMatrix>::Pvec (void) const
-{
-  Array<double> pa (p.col_perm_vec ());
-  RowVector pv (MArray<double> (pa) + 1.0);
-  return pv;
-}
+    template <>
+    RowVector
+    qrp<ComplexMatrix>::Pvec (void) const
+    {
+      Array<double> pa (p.col_perm_vec ());
+      RowVector pv (MArray<double> (pa) + 1.0);
+      return pv;
+    }
 
-template <>
-void
-qrp<FloatComplexMatrix>::init (const FloatComplexMatrix& a, type qr_type)
-{
-  assert (qr_type != qr<FloatComplexMatrix>::raw);
+    template <>
+    void
+    qrp<FloatComplexMatrix>::init (const FloatComplexMatrix& a, type qr_type)
+    {
+      assert (qr_type != qr<FloatComplexMatrix>::raw);
 
-  octave_idx_type m = a.rows ();
-  octave_idx_type n = a.cols ();
+      octave_idx_type m = a.rows ();
+      octave_idx_type n = a.cols ();
 
-  octave_idx_type min_mn = m < n ? m : n;
-  OCTAVE_LOCAL_BUFFER (FloatComplex, tau, min_mn);
+      octave_idx_type min_mn = m < n ? m : n;
+      OCTAVE_LOCAL_BUFFER (FloatComplex, tau, min_mn);
 
-  octave_idx_type info = 0;
+      octave_idx_type info = 0;
 
-  FloatComplexMatrix afact = a;
-  if (m > n && qr_type == qr<FloatComplexMatrix>::std)
-    afact.resize (m, m);
+      FloatComplexMatrix afact = a;
+      if (m > n && qr_type == qr<FloatComplexMatrix>::std)
+        afact.resize (m, m);
 
-  MArray<octave_idx_type> jpvt (dim_vector (n, 1), 0);
+      MArray<octave_idx_type> jpvt (dim_vector (n, 1), 0);
 
-  if (m > 0)
-    {
-      OCTAVE_LOCAL_BUFFER (float, rwork, 2*n);
+      if (m > 0)
+        {
+          OCTAVE_LOCAL_BUFFER (float, rwork, 2*n);
 
-      // workspace query.
-      FloatComplex clwork;
-      F77_XFCN (cgeqp3, CGEQP3, (m, n, F77_CMPLX_ARG (afact.fortran_vec ()),
-                                 m, jpvt.fortran_vec (), F77_CMPLX_ARG (tau),
-                                 F77_CMPLX_ARG (&clwork), -1, rwork, info));
+          // workspace query.
+          FloatComplex clwork;
+          F77_XFCN (cgeqp3, CGEQP3, (m, n, F77_CMPLX_ARG (afact.fortran_vec ()),
+                                     m, jpvt.fortran_vec (), F77_CMPLX_ARG (tau),
+                                     F77_CMPLX_ARG (&clwork), -1, rwork, info));
 
-      // allocate buffer and do the job.
-      octave_idx_type lwork = clwork.real ();
-      lwork = std::max (lwork, static_cast<octave_idx_type> (1));
-      OCTAVE_LOCAL_BUFFER (FloatComplex, work, lwork);
-      F77_XFCN (cgeqp3, CGEQP3, (m, n, F77_CMPLX_ARG (afact.fortran_vec ()),
-                                 m, jpvt.fortran_vec (), F77_CMPLX_ARG (tau),
-                                 F77_CMPLX_ARG (work), lwork, rwork, info));
+          // allocate buffer and do the job.
+          octave_idx_type lwork = clwork.real ();
+          lwork = std::max (lwork, static_cast<octave_idx_type> (1));
+          OCTAVE_LOCAL_BUFFER (FloatComplex, work, lwork);
+          F77_XFCN (cgeqp3, CGEQP3, (m, n, F77_CMPLX_ARG (afact.fortran_vec ()),
+                                     m, jpvt.fortran_vec (), F77_CMPLX_ARG (tau),
+                                     F77_CMPLX_ARG (work), lwork, rwork, info));
+        }
+      else
+        for (octave_idx_type i = 0; i < n; i++) jpvt(i) = i+1;
+
+      // Form Permutation matrix (if economy is requested, return the
+      // indices only!)
+
+      jpvt -= static_cast<octave_idx_type> (1);
+      p = PermMatrix (jpvt, true);
+
+      form (n, afact, tau, qr_type);
     }
-  else
-    for (octave_idx_type i = 0; i < n; i++) jpvt(i) = i+1;
+
+    template <>
+    qrp<FloatComplexMatrix>::qrp (const FloatComplexMatrix& a, type qr_type)
+      : qr<FloatComplexMatrix> (), p ()
+    {
+      init (a, qr_type);
+    }
 
-  // Form Permutation matrix (if economy is requested, return the
-  // indices only!)
-
-  jpvt -= static_cast<octave_idx_type> (1);
-  p = PermMatrix (jpvt, true);
-
-  form (n, afact, tau, qr_type);
+    template <>
+    FloatRowVector
+    qrp<FloatComplexMatrix>::Pvec (void) const
+    {
+      Array<float> pa (p.col_perm_vec ());
+      FloatRowVector pv (MArray<float> (pa) + 1.0f);
+      return pv;
+    }
+  }
 }
-
-template <>
-qrp<FloatComplexMatrix>::qrp (const FloatComplexMatrix& a, type qr_type)
-  : qr<FloatComplexMatrix> (), p ()
-{
-  init (a, qr_type);
-}
-
-template <>
-FloatRowVector
-qrp<FloatComplexMatrix>::Pvec (void) const
-{
-  Array<float> pa (p.col_perm_vec ());
-  FloatRowVector pv (MArray<float> (pa) + 1.0f);
-  return pv;
-}
-
-}
-}