Mercurial > octave

changeset 29680:e8a8ae9f512d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
update coding style in CollocWt class * CollocWt.h, CollocWt.cc: Use m_ prefix for data members. Use default copy constructor and assignment operator definitions.
author John W. Eaton <jwe@octave.org>
date Sun, 16 May 2021 09:52:37 -0400
parents 7ad7991e946a
children 25246c1a1645
files liboctave/numeric/CollocWt.cc liboctave/numeric/CollocWt.h
diffstat 2 files changed, 87 insertions(+), 97 deletions(-) [+]
line wrap: on
line diff
--- a/liboctave/numeric/CollocWt.cc	Sun May 16 14:38:11 2021 +0200
+++ b/liboctave/numeric/CollocWt.cc	Sun May 16 09:52:37 2021 -0400
@@ -387,22 +387,22 @@
 CollocWt&
 CollocWt::set_left (double val)
 {
-  if (val >= rb)
+  if (val >= m_rb)
     error ("CollocWt: left bound greater than right bound");
 
-  lb = val;
-  initialized = 0;
+  m_lb = val;
+  m_initialized = 0;
   return *this;
 }
 
 CollocWt&
 CollocWt::set_right (double val)
 {
-  if (val <= lb)
+  if (val <= m_lb)
     error ("CollocWt: right bound less than left bound");
 
-  rb = val;
-  initialized = 0;
+  m_rb = val;
+  m_initialized = 0;
   return *this;
 }
 
@@ -411,13 +411,13 @@
 {
   // Check for possible errors.
 
-  double wid = rb - lb;
+  double wid = m_rb - m_lb;
   if (wid <= 0.0)
     {
       error ("CollocWt: width less than or equal to zero");
     }
 
-  octave_idx_type nt = n + inc_left + inc_right;
+  octave_idx_type nt = m_n + m_inc_left + m_inc_right;
 
   if (nt < 0)
     error ("CollocWt: total number of collocation points less than zero");
@@ -436,16 +436,16 @@
   Array<double> vect (dim_vector (nt, 1));
   double *pvect = vect.fortran_vec ();
 
-  r.resize (nt, 1);
-  q.resize (nt, 1);
-  A.resize (nt, nt);
-  B.resize (nt, nt);
+  m_r.resize (nt, 1);
+  m_q.resize (nt, 1);
+  m_A.resize (nt, nt);
+  m_B.resize (nt, nt);
 
-  double *pr = r.fortran_vec ();
+  double *pr = m_r.fortran_vec ();
 
   // Compute roots.
 
-  if (! jcobi (n, inc_left, inc_right, Alpha, Beta, pdif1, pdif2, pdif3, pr))
+  if (! jcobi (m_n, m_inc_left, m_inc_right, m_alpha, m_beta, pdif1, pdif2, pdif3, pr))
     error ("jcobi: newton iteration failed");
 
   octave_idx_type id;
@@ -455,10 +455,10 @@
   id = 1;
   for (octave_idx_type i = 0; i < nt; i++)
     {
-      dfopr (n, inc_left, inc_right, i, id, pdif1, pdif2, pdif3, pr, pvect);
+      dfopr (m_n, m_inc_left, m_inc_right, i, id, pdif1, pdif2, pdif3, pr, pvect);
 
       for (octave_idx_type j = 0; j < nt; j++)
-        A(i,j) = vect(j);
+        m_A(i,j) = vect(j);
     }
 
   // Second derivative weights.
@@ -466,19 +466,19 @@
   id = 2;
   for (octave_idx_type i = 0; i < nt; i++)
     {
-      dfopr (n, inc_left, inc_right, i, id, pdif1, pdif2, pdif3, pr, pvect);
+      dfopr (m_n, m_inc_left, m_inc_right, i, id, pdif1, pdif2, pdif3, pr, pvect);
 
       for (octave_idx_type j = 0; j < nt; j++)
-        B(i,j) = vect(j);
+        m_B(i,j) = vect(j);
     }
 
   // Gaussian quadrature weights.
 
   id = 3;
-  double *pq = q.fortran_vec ();
-  dfopr (n, inc_left, inc_right, id, id, pdif1, pdif2, pdif3, pr, pq);
+  double *pq = m_q.fortran_vec ();
+  dfopr (m_n, m_inc_left, m_inc_right, id, id, pdif1, pdif2, pdif3, pr, pq);
 
-  initialized = 1;
+  m_initialized = 1;
 }
 
 std::ostream&
@@ -496,11 +496,11 @@
 
   os << "\n";
 
-  os << a.Alpha << ' ' << a.Beta << "\n\n"
-     << a.r << "\n\n"
-     << a.q << "\n\n"
-     << a.A << "\n"
-     << a.B << "\n";
+  os << a.m_alpha << ' ' << a.m_beta << "\n\n"
+     << a.m_r << "\n\n"
+     << a.m_q << "\n\n"
+     << a.m_A << "\n"
+     << a.m_B << "\n";
 
   return os;
 }
--- a/liboctave/numeric/CollocWt.h	Sun May 16 14:38:11 2021 +0200
+++ b/liboctave/numeric/CollocWt.h	Sun May 16 09:52:37 2021 -0400
@@ -40,73 +40,63 @@
 public:
 
   CollocWt (void)
-    : n (0), inc_left (0), inc_right (0), lb (0.0), rb (1.0),
-      Alpha (0.0), Beta (0.0), r (), q (), A (), B (), initialized (false) { }
+    : m_n (0), m_inc_left (0), m_inc_right (0), m_lb (0.0), m_rb (1.0),
+      m_alpha (0.0), m_beta (0.0), m_r (), m_q (), m_A (), m_B (),
+      m_initialized (false)
+  { }
 
   CollocWt (octave_idx_type nc, octave_idx_type il, octave_idx_type ir)
-    : n (nc), inc_left (il), inc_right (ir), lb (0.0), rb (1.0),
-      Alpha (0.0), Beta (0.0), r (), q (), A (), B (), initialized (false) { }
+    : m_n (nc), m_inc_left (il), m_inc_right (ir), m_lb (0.0), m_rb (1.0),
+      m_alpha (0.0), m_beta (0.0), m_r (), m_q (), m_A (), m_B (),
+      m_initialized (false)
+  { }
 
   CollocWt (octave_idx_type nc, octave_idx_type il, octave_idx_type ir,
             double l, double rr)
-    : n (nc), inc_left (il), inc_right (ir), lb (l), rb (rr),
-      Alpha (0.0), Beta (0.0), r (), q (), A (), B (), initialized (false) { }
+    : m_n (nc), m_inc_left (il), m_inc_right (ir), m_lb (l), m_rb (rr),
+      m_alpha (0.0), m_beta (0.0), m_r (), m_q (), m_A (), m_B (),
+      m_initialized (false)
+  { }
 
   CollocWt (octave_idx_type nc, double a, double b, octave_idx_type il,
             octave_idx_type ir)
-    : n (nc), inc_left (il), inc_right (ir), lb (0.0), rb (1.0),
-      Alpha (a), Beta (b), r (), q (), A (), B (), initialized (false) { }
+    : m_n (nc), m_inc_left (il), m_inc_right (ir), m_lb (0.0), m_rb (1.0),
+      m_alpha (a), m_beta (b), m_r (), m_q (), m_A (), m_B (),
+      m_initialized (false)
+  { }
 
   CollocWt (octave_idx_type nc, double a, double b, octave_idx_type il,
             octave_idx_type ir,
             double ll, double rr)
-    : n (nc), inc_left (il), inc_right (ir), lb (ll), rb (rr),
-      Alpha (a), Beta (b), r (), q (), A (), B (), initialized (false) { }
-
-  CollocWt (const CollocWt& a)
-    : n (a.n), inc_left (a.inc_left), inc_right (a.inc_right),
-      lb (a.lb), rb (a.rb), Alpha (a.Alpha), Beta (a.Beta),
-      r (a.r), q (a.q), A (a.A), B (a.B),
-      initialized (a.initialized) { }
+    : m_n (nc), m_inc_left (il), m_inc_right (ir), m_lb (ll), m_rb (rr),
+      m_alpha (a), m_beta (b), m_r (), m_q (), m_A (), m_B (),
+      m_initialized (false)
+  { }
 
-  CollocWt& operator = (const CollocWt& a)
-  {
-    if (this != &a)
-      {
-        n = a.n;
-        inc_left = a.inc_left;
-        inc_right = a.inc_right;
-        lb = a.lb;
-        rb = a.rb;
-        r = a.r;
-        q = a.q;
-        A = a.A;
-        B = a.B;
-        initialized = a.initialized;
-      }
-    return *this;
-  }
+  CollocWt (const CollocWt& a) = default;
+
+  CollocWt& operator = (const CollocWt& a) = default;
 
   ~CollocWt (void) = default;
 
   CollocWt& resize (octave_idx_type nc)
   {
-    n = nc;
-    initialized = false;
+    m_n = nc;
+    m_initialized = false;
     return *this;
   }
 
   CollocWt& add_left (void)
   {
-    inc_left = 1;
-    initialized = false;
+    m_inc_left = 1;
+    m_initialized = false;
     return *this;
   }
 
   CollocWt& delete_left (void)
   {
-    inc_left = 0;
-    initialized = false;
+    m_inc_left = 0;
+    m_initialized = false;
     return *this;
   }
 
@@ -114,15 +104,15 @@
 
   CollocWt& add_right (void)
   {
-    inc_right = 1;
-    initialized = false;
+    m_inc_right = 1;
+    m_initialized = false;
     return *this;
   }
 
   CollocWt& delete_right (void)
   {
-    inc_right = 0;
-    initialized = false;
+    m_inc_right = 0;
+    m_initialized = false;
     return *this;
   }
 
@@ -130,62 +120,62 @@
 
   CollocWt& set_alpha (double val)
   {
-    Alpha = val;
-    initialized = false;
+    m_alpha = val;
+    m_initialized = false;
     return *this;
   }
 
   CollocWt& set_beta (double val)
   {
-    Beta = val;
-    initialized = false;
+    m_beta = val;
+    m_initialized = false;
     return *this;
   }
 
-  octave_idx_type ncol (void) const { return n; }
+  octave_idx_type ncol (void) const { return m_n; }
 
-  octave_idx_type left_included (void) const { return inc_left; }
-  octave_idx_type right_included (void) const { return inc_right; }
+  octave_idx_type left_included (void) const { return m_inc_left; }
+  octave_idx_type right_included (void) const { return m_inc_right; }
 
-  double left (void) const { return lb; }
-  double right (void) const { return rb; }
+  double left (void) const { return m_lb; }
+  double right (void) const { return m_rb; }
 
-  double width (void) const { return rb - lb; }
+  double width (void) const { return m_rb - m_lb; }
 
-  double alpha (void) const { return Alpha; }
-  double beta (void) const { return Beta; }
+  double alpha (void) const { return m_alpha; }
+  double beta (void) const { return m_beta; }
 
-  ColumnVector roots (void) { if (! initialized) init (); return r; }
-  ColumnVector quad (void) { if (! initialized) init (); return q; }
+  ColumnVector roots (void) { if (! m_initialized) init (); return m_r; }
+  ColumnVector quad (void) { if (! m_initialized) init (); return m_q; }
 
   ColumnVector quad_weights (void) { return quad (); }
 
-  Matrix first (void) { if (! initialized) init (); return A; }
+  Matrix first (void) { if (! m_initialized) init (); return m_A; }
 
-  Matrix second (void) { if (! initialized) init (); return B; }
+  Matrix second (void) { if (! m_initialized) init (); return m_B; }
 
   friend std::ostream& operator << (std::ostream&, const CollocWt&);
 
 protected:
 
-  octave_idx_type n;
+  octave_idx_type m_n;
 
-  octave_idx_type inc_left;
-  octave_idx_type inc_right;
+  octave_idx_type m_inc_left;
+  octave_idx_type m_inc_right;
 
-  double lb;
-  double rb;
+  double m_lb;
+  double m_rb;
 
-  double Alpha;
-  double Beta;
+  double m_alpha;
+  double m_beta;
 
-  ColumnVector r;
-  ColumnVector q;
+  ColumnVector m_r;
+  ColumnVector m_q;
 
-  Matrix A;
-  Matrix B;
+  Matrix m_A;
+  Matrix m_B;
 
-  bool initialized;
+  bool m_initialized;
 
   void init (void);