# HG changeset patch
# User Rik <rik@octave.org>
# Date 1630348536 25200
# Node ID 443571d367feaece1c2c293a0ec49a01fe097c10
# Parent  b16e0d357437dd8d912d0c3ab2f567dae3870e3a
maint: use "m_" prefix for member variables in class aepbalance.

* aepbalance.cc, aepbalance.h: use "m_" prefix for member variables in class
aepbalance.

diff -r b16e0d357437 -r 443571d367fe liboctave/numeric/aepbalance.cc
--- a/liboctave/numeric/aepbalance.cc	Mon Aug 30 14:02:47 2021 -0400
+++ b/liboctave/numeric/aepbalance.cc	Mon Aug 30 11:35:36 2021 -0700
@@ -50,8 +50,8 @@
     template <>
     OCTAVE_API
     aepbalance<Matrix>::aepbalance (const Matrix& a, bool noperm, bool noscal)
-      : balanced_mat (a), scale (), ilo (), ihi (),
-        job (get_job (noperm, noscal))
+      : m_balanced_mat (a), m_scale (), m_ilo (), m_ihi (),
+        m_job (get_job (noperm, noscal))
     {
       F77_INT n = to_f77_int (a.cols ());
 
@@ -59,38 +59,38 @@
         (*current_liboctave_error_handler)
           ("aepbalance: requires square matrix");
 
-      scale = ColumnVector (n);
+      m_scale = ColumnVector (n);
 
       F77_INT info, t_ilo, t_ihi;
 
-      F77_XFCN (dgebal, DGEBAL, (F77_CONST_CHAR_ARG2 (&job, 1), n,
-                                 balanced_mat.fortran_vec (), n,
-                                 t_ilo, t_ihi, scale.fortran_vec (), info
+      F77_XFCN (dgebal, DGEBAL, (F77_CONST_CHAR_ARG2 (&m_job, 1), n,
+                                 m_balanced_mat.fortran_vec (), n,
+                                 t_ilo, t_ihi, m_scale.fortran_vec (), info
                                  F77_CHAR_ARG_LEN (1)));
 
-      ilo = t_ilo;
-      ihi = t_ihi;
+      m_ilo = t_ilo;
+      m_ihi = t_ihi;
     }
 
     template <>
     OCTAVE_API Matrix
     aepbalance<Matrix>::balancing_matrix (void) const
     {
-      F77_INT n = to_f77_int (balanced_mat.rows ());
+      F77_INT n = to_f77_int (m_balanced_mat.rows ());
 
       Matrix balancing_mat (n, n, 0.0);
       for (F77_INT i = 0; i < n; i++)
         balancing_mat.elem (i ,i) = 1.0;
 
       F77_INT info;
-      F77_INT t_ilo = to_f77_int (ilo);
-      F77_INT t_ihi = to_f77_int (ihi);
+      F77_INT t_ilo = to_f77_int (m_ilo);
+      F77_INT t_ihi = to_f77_int (m_ihi);
 
       char side = 'R';
 
-      F77_XFCN (dgebak, DGEBAK, (F77_CONST_CHAR_ARG2 (&job, 1),
+      F77_XFCN (dgebak, DGEBAK, (F77_CONST_CHAR_ARG2 (&m_job, 1),
                                  F77_CONST_CHAR_ARG2 (&side, 1),
-                                 n, t_ilo, t_ihi, scale.data (), n,
+                                 n, t_ilo, t_ihi, m_scale.data (), n,
                                  balancing_mat.fortran_vec (), n, info
                                  F77_CHAR_ARG_LEN (1)
                                  F77_CHAR_ARG_LEN (1)));
@@ -102,8 +102,8 @@
     OCTAVE_API
     aepbalance<FloatMatrix>::aepbalance (const FloatMatrix& a, bool noperm,
                                          bool noscal)
-      : balanced_mat (a), scale (), ilo (), ihi (),
-        job (get_job (noperm, noscal))
+      : m_balanced_mat (a), m_scale (), m_ilo (), m_ihi (),
+        m_job (get_job (noperm, noscal))
     {
       F77_INT n = to_f77_int (a.cols ());
 
@@ -111,38 +111,38 @@
         (*current_liboctave_error_handler)
           ("aepbalance: requires square matrix");
 
-      scale = FloatColumnVector (n);
+      m_scale = FloatColumnVector (n);
 
       F77_INT info, t_ilo, t_ihi;
 
-      F77_XFCN (sgebal, SGEBAL, (F77_CONST_CHAR_ARG2 (&job, 1), n,
-                                 balanced_mat.fortran_vec (), n, t_ilo,
-                                 t_ihi, scale.fortran_vec (), info
+      F77_XFCN (sgebal, SGEBAL, (F77_CONST_CHAR_ARG2 (&m_job, 1), n,
+                                 m_balanced_mat.fortran_vec (), n, t_ilo,
+                                 t_ihi, m_scale.fortran_vec (), info
                                  F77_CHAR_ARG_LEN (1)));
 
-      ilo = t_ilo;
-      ihi = t_ihi;
+      m_ilo = t_ilo;
+      m_ihi = t_ihi;
     }
 
     template <>
     OCTAVE_API FloatMatrix
     aepbalance<FloatMatrix>::balancing_matrix (void) const
     {
-      F77_INT n = to_f77_int (balanced_mat.rows ());
+      F77_INT n = to_f77_int (m_balanced_mat.rows ());
 
       FloatMatrix balancing_mat (n, n, 0.0);
       for (F77_INT i = 0; i < n; i++)
         balancing_mat.elem (i,i) = 1.0;
 
       F77_INT info;
-      F77_INT t_ilo = to_f77_int (ilo);
-      F77_INT t_ihi = to_f77_int (ihi);
+      F77_INT t_ilo = to_f77_int (m_ilo);
+      F77_INT t_ihi = to_f77_int (m_ihi);
 
       char side = 'R';
 
-      F77_XFCN (sgebak, SGEBAK, (F77_CONST_CHAR_ARG2 (&job, 1),
+      F77_XFCN (sgebak, SGEBAK, (F77_CONST_CHAR_ARG2 (&m_job, 1),
                                  F77_CONST_CHAR_ARG2 (&side, 1),
-                                 n, t_ilo, t_ihi, scale.data (), n,
+                                 n, t_ilo, t_ihi, m_scale.data (), n,
                                  balancing_mat.fortran_vec (), n, info
                                  F77_CHAR_ARG_LEN (1)
                                  F77_CHAR_ARG_LEN (1)));
@@ -154,8 +154,8 @@
     OCTAVE_API
     aepbalance<ComplexMatrix>::aepbalance (const ComplexMatrix& a, bool noperm,
                                            bool noscal)
-      : balanced_mat (a), scale (), ilo (), ihi (),
-        job (get_job (noperm, noscal))
+      : m_balanced_mat (a), m_scale (), m_ilo (), m_ihi (),
+        m_job (get_job (noperm, noscal))
     {
       F77_INT n = to_f77_int (a.cols ());
 
@@ -163,42 +163,44 @@
         (*current_liboctave_error_handler)
           ("aepbalance: requires square matrix");
 
-      scale = ColumnVector (n);
+      m_scale = ColumnVector (n);
 
       F77_INT info, t_ilo, t_ihi;
 
-      F77_XFCN (zgebal, ZGEBAL, (F77_CONST_CHAR_ARG2 (&job, 1), n,
-                                 F77_DBLE_CMPLX_ARG (balanced_mat.fortran_vec ()),
-                                 n, t_ilo, t_ihi, scale.fortran_vec (), info
-                                 F77_CHAR_ARG_LEN (1)));
+      F77_XFCN (zgebal, ZGEBAL,
+                (F77_CONST_CHAR_ARG2 (&m_job, 1), n,
+                 F77_DBLE_CMPLX_ARG (m_balanced_mat.fortran_vec ()),
+                 n, t_ilo, t_ihi, m_scale.fortran_vec (), info
+                 F77_CHAR_ARG_LEN (1)));
 
-      ilo = t_ilo;
-      ihi = t_ihi;
+      m_ilo = t_ilo;
+      m_ihi = t_ihi;
     }
 
     template <>
     OCTAVE_API ComplexMatrix
     aepbalance<ComplexMatrix>::balancing_matrix (void) const
     {
-      F77_INT n = to_f77_int (balanced_mat.rows ());
+      F77_INT n = to_f77_int (m_balanced_mat.rows ());
 
       ComplexMatrix balancing_mat (n, n, 0.0);
       for (F77_INT i = 0; i < n; i++)
         balancing_mat.elem (i, i) = 1.0;
 
       F77_INT info;
-      F77_INT t_ilo = to_f77_int (ilo);
-      F77_INT t_ihi = to_f77_int (ihi);
+      F77_INT t_ilo = to_f77_int (m_ilo);
+      F77_INT t_ihi = to_f77_int (m_ihi);
 
       char side = 'R';
 
-      F77_XFCN (zgebak, ZGEBAK, (F77_CONST_CHAR_ARG2 (&job, 1),
-                                 F77_CONST_CHAR_ARG2 (&side, 1),
-                                 n, t_ilo, t_ihi, scale.data (), n,
-                                 F77_DBLE_CMPLX_ARG (balancing_mat.fortran_vec ()),
-                                 n, info
-                                 F77_CHAR_ARG_LEN (1)
-                                 F77_CHAR_ARG_LEN (1)));
+      F77_XFCN (zgebak, ZGEBAK,
+                (F77_CONST_CHAR_ARG2 (&m_job, 1),
+                 F77_CONST_CHAR_ARG2 (&side, 1),
+                 n, t_ilo, t_ihi, m_scale.data (), n,
+                 F77_DBLE_CMPLX_ARG (balancing_mat.fortran_vec ()),
+                 n, info
+                 F77_CHAR_ARG_LEN (1)
+                 F77_CHAR_ARG_LEN (1)));
 
       return balancing_mat;
     }
@@ -207,8 +209,8 @@
     OCTAVE_API
     aepbalance<FloatComplexMatrix>::aepbalance (const FloatComplexMatrix& a,
                                                 bool noperm, bool noscal)
-      : balanced_mat (a), scale (), ilo (), ihi (),
-        job (get_job (noperm, noscal))
+      : m_balanced_mat (a), m_scale (), m_ilo (), m_ihi (),
+        m_job (get_job (noperm, noscal))
     {
       F77_INT n = to_f77_int (a.cols ());
 
@@ -216,38 +218,38 @@
         (*current_liboctave_error_handler)
           ("aepbalance: requires square matrix");
 
-      scale = FloatColumnVector (n);
+      m_scale = FloatColumnVector (n);
 
       F77_INT info, t_ilo, t_ihi;
 
-      F77_XFCN (cgebal, CGEBAL, (F77_CONST_CHAR_ARG2 (&job, 1), n,
-                                 F77_CMPLX_ARG (balanced_mat.fortran_vec ()),
-                                 n, t_ilo, t_ihi, scale.fortran_vec (), info
+      F77_XFCN (cgebal, CGEBAL, (F77_CONST_CHAR_ARG2 (&m_job, 1), n,
+                                 F77_CMPLX_ARG (m_balanced_mat.fortran_vec ()),
+                                 n, t_ilo, t_ihi, m_scale.fortran_vec (), info
                                  F77_CHAR_ARG_LEN (1)));
 
-      ilo = t_ilo;
-      ihi = t_ihi;
+      m_ilo = t_ilo;
+      m_ihi = t_ihi;
     }
 
     template <>
     OCTAVE_API FloatComplexMatrix
     aepbalance<FloatComplexMatrix>::balancing_matrix (void) const
     {
-      F77_INT n = to_f77_int (balanced_mat.rows ());
+      F77_INT n = to_f77_int (m_balanced_mat.rows ());
 
       FloatComplexMatrix balancing_mat (n, n, 0.0);
       for (F77_INT i = 0; i < n; i++)
         balancing_mat.elem (i, i) = 1.0;
 
       F77_INT info;
-      F77_INT t_ilo = to_f77_int (ilo);
-      F77_INT t_ihi = to_f77_int (ihi);
+      F77_INT t_ilo = to_f77_int (m_ilo);
+      F77_INT t_ihi = to_f77_int (m_ihi);
 
       char side = 'R';
 
-      F77_XFCN (cgebak, CGEBAK, (F77_CONST_CHAR_ARG2 (&job, 1),
+      F77_XFCN (cgebak, CGEBAK, (F77_CONST_CHAR_ARG2 (&m_job, 1),
                                  F77_CONST_CHAR_ARG2 (&side, 1),
-                                 n, t_ilo, t_ihi, scale.data (), n,
+                                 n, t_ilo, t_ihi, m_scale.data (), n,
                                  F77_CMPLX_ARG (balancing_mat.fortran_vec ()),
                                  n, info
                                  F77_CHAR_ARG_LEN (1)
diff -r b16e0d357437 -r 443571d367fe liboctave/numeric/aepbalance.h
--- a/liboctave/numeric/aepbalance.h	Mon Aug 30 14:02:47 2021 -0400
+++ b/liboctave/numeric/aepbalance.h	Mon Aug 30 11:35:36 2021 -0700
@@ -42,24 +42,24 @@
 
       typedef typename MT::real_column_vector_type VT;
 
-      aepbalance (void) : balanced_mat (), scale (), ilo (), ihi (), job () { }
+      aepbalance (void) : m_balanced_mat (), m_scale (), m_ilo (), m_ihi (), m_job () { }
 
       OCTAVE_API aepbalance (const MT& a, bool noperm = false, bool noscal = false);
 
       aepbalance (const aepbalance& a)
-        : balanced_mat (a.balanced_mat), scale (a.scale),
-          ilo(a.ilo), ihi(a.ihi), job(a.job)
+        : m_balanced_mat (a.m_balanced_mat), m_scale (a.m_scale),
+          m_ilo(a.m_ilo), m_ihi(a.m_ihi), m_job(a.m_job)
       { }
 
       aepbalance& operator = (const aepbalance& a)
       {
         if (this != &a)
           {
-            balanced_mat = a.balanced_mat;
-            scale = a.scale;
-            ilo = a.ilo;
-            ihi = a.ihi;
-            job = a.job;
+            m_balanced_mat = a.m_balanced_mat;
+            m_scale = a.m_scale;
+            m_ilo = a.m_ilo;
+            m_ihi = a.m_ihi;
+            m_job = a.m_job;
           }
 
         return *this;
@@ -71,27 +71,27 @@
 
       MT balanced_matrix (void) const
       {
-        return balanced_mat;
+        return m_balanced_mat;
       }
 
       VT permuting_vector (void) const
       {
-        octave_idx_type n = balanced_mat.rows ();
+        octave_idx_type n = m_balanced_mat.rows ();
 
         VT pv (n);
 
         for (octave_idx_type i = 0; i < n; i++)
           pv(i) = i+1;
 
-        for (octave_idx_type i = n-1; i >= ihi; i--)
+        for (octave_idx_type i = n-1; i >= m_ihi; i--)
           {
-            octave_idx_type j = scale(i) - 1;
+            octave_idx_type j = m_scale(i) - 1;
             std::swap (pv(i), pv(j));
           }
 
-        for (octave_idx_type i = 0; i < ilo-1; i++)
+        for (octave_idx_type i = 0; i < m_ilo-1; i++)
           {
-            octave_idx_type j = scale(i) - 1;
+            octave_idx_type j = m_scale(i) - 1;
             std::swap (pv(i), pv(j));
           }
 
@@ -100,17 +100,17 @@
 
       VT scaling_vector (void) const
       {
-        octave_idx_type n = balanced_mat.rows ();
+        octave_idx_type n = m_balanced_mat.rows ();
 
         VT scv (n);
 
-        for (octave_idx_type i = 0; i < ilo-1; i++)
+        for (octave_idx_type i = 0; i < m_ilo-1; i++)
           scv(i) = 1;
 
-        for (octave_idx_type i = ilo-1; i < ihi; i++)
-          scv(i) = scale(i);
+        for (octave_idx_type i = m_ilo-1; i < m_ihi; i++)
+          scv(i) = m_scale(i);
 
-        for (octave_idx_type i = ihi; i < n; i++)
+        for (octave_idx_type i = m_ihi; i < n; i++)
           scv(i) = 1;
 
         return scv;
@@ -118,11 +118,11 @@
 
     protected:
 
-      MT balanced_mat;
-      VT scale;
-      octave_idx_type ilo;
-      octave_idx_type ihi;
-      char job;
+      MT m_balanced_mat;
+      VT m_scale;
+      octave_idx_type m_ilo;
+      octave_idx_type m_ihi;
+      char m_job;
     };
   }
 }