# HG changeset patch
# User John W. Eaton <jwe@octave.org>
# Date 1294904265 18000
# Node ID 367bfee35ba00e69e82adeb60f68d2c211ee86ab
# Parent  7bddd70bc838902b6a710a7b77493c1f4203b2c1
data member initialization fixes

diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/ChangeLog
--- a/liboctave/ChangeLog	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/ChangeLog	Thu Jan 13 02:37:45 2011 -0500
@@ -1,3 +1,37 @@
+2011-01-13  John W. Eaton  <jwe@octave.org>
+
+	* CmplxCHOL.h (ComplexCHOL::ComplexCHOL): Initialize all data
+	members in constructor initialization lists.
+	* CmplxGEPBAL.h (ComplexGEPBALANCE::ComplexGEPBALANCE): Likewise.
+	* CmplxHESS.h (ComplexHESS::ComplexHESS): Likewise.
+	* CmplxSCHUR.h, CmplxSCHUR.cc (ComplexSCHUR::ComplexSCHUR): Likewise.
+	* CmplxSVD.h (ComplexSVD::ComplexSVD): Likewise.
+	* DET.h (base_det::base_det): Likewise.
+	* EIG.h (EIG::EIG): Likewise.
+	* SparseCmplxQR.cc
+	(SparseComplexQR::SparseComplexQR_rep::SparseComplexQR_rep):
+	Likewise.
+	* SparseQR.cc (SparseQR::SparseQR_rep::SparseQR_rep): Likewise.
+	* dbleCHOL.h (CHOL::CHOL): Likewise.
+	* dbleGEPBAL.h (GEPBALANCE::GEPBALANCE): Likewise.
+	* dbleHESS.h (HESS::HESS): Likewise.
+	* dbleSCHUR.h, dbleSCHUR.cc (SCHUR::SCHUR): Likewise.
+	* dbleSVD.h (SVD::SVD): Likewise.
+	* fCmplxCHOL.h (FloatComplexCHOL::FloatComplexCHOL): Likewise.
+	* fCmplxGEPBAL.h
+	(FloatComplexGEPBALANCE::FloatComplexGEPBALANCE): Likewise.
+	* fCmplxHESS.h (FloatComplexHESS::FloatComplexHESS): Likewise.
+	* fCmplxSCHUR.h, fCmplxSCHUR.cc
+	(FloatComplexSCHUR::FloatComplexSCHUR): Likewise.
+	* fCmplxSVD.h (FloatComplexSVD::FloatComplexSVD):
+	Likewise.
+	* fEIG.h (FloatEIG::FloatEIG): Likewise.
+	* floatCHOL.h (FloatCHOL::FloatCHOL): Likewise.
+	* floatGEPBAL.h (FloatGEPBALANCE::FloatGEPBALANCE): Likewise.
+	* floatHESS.h (FloatHESS::FloatHESS): Likewise.
+	* floatSCHUR.h, floatSCHUR.cc (FloatSCHUR::FloatSCHUR): Likewise.
+	* floatSVD.h (FloatSVD::FloatSVD): Likewise.
+
 2011-01-13  John W. Eaton  <jwe@octave.org>
 
 	* LSODE.cc, DASSL.cc, DASRT.cc, DASPK.cc, CmplxSVD.cc,
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/CmplxCHOL.h
--- a/liboctave/CmplxCHOL.h	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/CmplxCHOL.h	Thu Jan 13 02:37:45 2011 -0500
@@ -36,11 +36,17 @@
 {
 public:
 
-  ComplexCHOL (void) : chol_mat () { }
+  ComplexCHOL (void) : chol_mat (), xrcond (0) { }
 
-  ComplexCHOL (const ComplexMatrix& a, bool calc_cond = false) { init (a, calc_cond); }
+  ComplexCHOL (const ComplexMatrix& a, bool calc_cond = false)
+    : chol_mat (), xrcond (0)
+    {
+      init (a, calc_cond);
+    }
 
-  ComplexCHOL (const ComplexMatrix& a, octave_idx_type& info, bool calc_cond = false)
+  ComplexCHOL (const ComplexMatrix& a, octave_idx_type& info,
+               bool calc_cond = false)
+    : chol_mat (), xrcond (0)
     {
       info = init (a, calc_cond);
     }
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/CmplxGEPBAL.h
--- a/liboctave/CmplxGEPBAL.h	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/CmplxGEPBAL.h	Thu Jan 13 02:37:45 2011 -0500
@@ -36,16 +36,20 @@
 {
 public:
 
-  ComplexGEPBALANCE (void) : balanced_mat (), balancing_mat () { }
+  ComplexGEPBALANCE (void)
+    : balanced_mat (), balanced_mat2 (), balancing_mat (), balancing_mat2 ()
+    { }
 
-  ComplexGEPBALANCE (const ComplexMatrix& a, const ComplexMatrix& b, const std::string& balance_job)
+  ComplexGEPBALANCE (const ComplexMatrix& a, const ComplexMatrix& b,
+                     const std::string& balance_job)
+    : balanced_mat (), balanced_mat2 (), balancing_mat (), balancing_mat2 ()
     {
       init (a, b, balance_job); 
     }
 
   ComplexGEPBALANCE (const ComplexGEPBALANCE& a)
     : balanced_mat (a.balanced_mat), balanced_mat2 (a.balanced_mat2),
-    balancing_mat (a.balancing_mat), balancing_mat2 (a.balancing_mat2) { }
+      balancing_mat (a.balancing_mat), balancing_mat2 (a.balancing_mat2) { }
 
   ComplexGEPBALANCE& operator = (const ComplexGEPBALANCE& a)
     {
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/CmplxHESS.h
--- a/liboctave/CmplxHESS.h	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/CmplxHESS.h	Thu Jan 13 02:37:45 2011 -0500
@@ -36,9 +36,17 @@
 
   ComplexHESS (void) : hess_mat (), unitary_hess_mat () { }
 
-  ComplexHESS (const ComplexMatrix& a) { init (a); }
+  ComplexHESS (const ComplexMatrix& a)
+    : hess_mat (), unitary_hess_mat ()
+    {
+      init (a);
+    }
 
-  ComplexHESS (const ComplexMatrix& a, octave_idx_type& info) { info = init (a); }
+  ComplexHESS (const ComplexMatrix& a, octave_idx_type& info)
+    : hess_mat (), unitary_hess_mat ()
+    {
+      info = init (a);
+    }
 
   ComplexHESS (const ComplexHESS& a)
     : hess_mat (a.hess_mat), unitary_hess_mat (a.unitary_hess_mat) { }
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/CmplxSCHUR.cc
--- a/liboctave/CmplxSCHUR.cc	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/CmplxSCHUR.cc	Thu Jan 13 02:37:45 2011 -0500
@@ -148,9 +148,8 @@
   return info;
 }
 
-ComplexSCHUR::ComplexSCHUR (const ComplexMatrix& s, 
-                            const ComplexMatrix& u)
-: schur_mat (s), unitary_mat (u)
+ComplexSCHUR::ComplexSCHUR (const ComplexMatrix& s, const ComplexMatrix& u)
+  : schur_mat (s), unitary_mat (u), selector (0)
 {
   octave_idx_type n = s.rows ();
   if (s.columns () != n || u.rows () != n || u.columns () != n)
@@ -159,7 +158,8 @@
 }
 
 ComplexSCHUR::ComplexSCHUR (const SCHUR& s)
-: schur_mat (s.schur_matrix ()), unitary_mat (s.unitary_matrix ())
+  : schur_mat (s.schur_matrix ()), unitary_mat (s.unitary_matrix ()),
+    selector (0)
 {
   octave_idx_type n = schur_mat.rows ();
   if (n > 0)
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/CmplxSCHUR.h
--- a/liboctave/CmplxSCHUR.h	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/CmplxSCHUR.h	Thu Jan 13 02:37:45 2011 -0500
@@ -36,19 +36,26 @@
 {
 public:
 
-  ComplexSCHUR (void)
-    : schur_mat (), unitary_mat () { }
+  ComplexSCHUR (void) : schur_mat (), unitary_mat (), selector (0) { }
 
   ComplexSCHUR (const ComplexMatrix& a, const std::string& ord,
                 bool calc_unitary = true)
-    : schur_mat (), unitary_mat () { init (a, ord, calc_unitary); }
+    : schur_mat (), unitary_mat (), selector (0)
+    {
+      init (a, ord, calc_unitary);
+    }
 
-  ComplexSCHUR (const ComplexMatrix& a, const std::string& ord, octave_idx_type& info,
+  ComplexSCHUR (const ComplexMatrix& a, const std::string& ord,
+                octave_idx_type& info,
                 bool calc_unitary = true)
-    : schur_mat (), unitary_mat () { info = init (a, ord, calc_unitary); }
+    : schur_mat (), unitary_mat (), selector (0)
+    {
+      info = init (a, ord, calc_unitary);
+    }
 
   ComplexSCHUR (const ComplexSCHUR& a)
-    : schur_mat (a.schur_mat), unitary_mat (a.unitary_mat) { }
+    : schur_mat (a.schur_mat), unitary_mat (a.unitary_mat), selector (0)
+    { }
 
   ComplexSCHUR (const ComplexMatrix& s, const ComplexMatrix& u);
 
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/CmplxSVD.h
--- a/liboctave/CmplxSVD.h	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/CmplxSVD.h	Thu Jan 13 02:37:45 2011 -0500
@@ -36,23 +36,29 @@
 {
 public:
 
-  ComplexSVD (void) { }
+  ComplexSVD (void)
+    : type_computed (), sigma (), left_sm (), right_sm ()
+    { }
 
-  ComplexSVD (const ComplexMatrix& a, 
-              SVD::type svd_type = SVD::std, SVD::driver svd_driver = SVD::GESVD) 
+  ComplexSVD (const ComplexMatrix& a, SVD::type svd_type = SVD::std,
+              SVD::driver svd_driver = SVD::GESVD) 
+    : type_computed (), sigma (), left_sm (), right_sm ()
     {
-    { init (a, svd_type, svd_driver); }
+      init (a, svd_type, svd_driver);
     }
 
   ComplexSVD (const ComplexMatrix& a, octave_idx_type& info,
-              SVD::type svd_type = SVD::std, SVD::driver svd_driver = SVD::GESVD) 
+              SVD::type svd_type = SVD::std,
+              SVD::driver svd_driver = SVD::GESVD) 
+    : type_computed (), sigma (), left_sm (), right_sm ()
     {
       info = init (a, svd_type, svd_driver);
     }
 
   ComplexSVD (const ComplexSVD& a)
-    : type_computed (a.type_computed),
-      sigma (a.sigma), left_sm (a.left_sm), right_sm (a.right_sm) { }
+    : type_computed (a.type_computed), sigma (a.sigma),
+      left_sm (a.left_sm), right_sm (a.right_sm)
+    { }
 
   ComplexSVD& operator = (const ComplexSVD& a)
     {
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/EIG.h
--- a/liboctave/EIG.h	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/EIG.h	Thu Jan 13 02:37:45 2011 -0500
@@ -39,32 +39,59 @@
 
 public:
 
-  EIG (void)
-    : lambda (), v () { }
+  EIG (void) : lambda (), v () { }
 
   EIG (const Matrix& a, bool calc_eigenvectors = true)
-    { init (a, calc_eigenvectors); }
+    : lambda (), v ()
+  {
+    init (a, calc_eigenvectors);
+  }
 
   EIG (const Matrix& a, octave_idx_type& info, bool calc_eigenvectors = true)
-    { info = init (a, calc_eigenvectors); }
+    : lambda (), v ()
+  {
+    info = init (a, calc_eigenvectors);
+  }
 
   EIG (const Matrix& a, const Matrix& b, bool calc_eigenvectors = true)
-    { init (a, b, calc_eigenvectors); }
+    : lambda (), v ()
+  {
+    init (a, b, calc_eigenvectors);
+  }
 
-  EIG (const Matrix& a, const Matrix& b, octave_idx_type& info, bool calc_eigenvectors = true)
-    { info = init (a, b, calc_eigenvectors); }
+  EIG (const Matrix& a, const Matrix& b, octave_idx_type& info,
+       bool calc_eigenvectors = true)
+    : lambda (), v ()
+  {
+    info = init (a, b, calc_eigenvectors);
+  }
 
   EIG (const ComplexMatrix& a, bool calc_eigenvectors = true)
-    { init (a, calc_eigenvectors); }
+    : lambda (), v ()
+  {
+    init (a, calc_eigenvectors);
+  }
 
-  EIG (const ComplexMatrix& a, octave_idx_type& info, bool calc_eigenvectors = true)
-    { info = init (a, calc_eigenvectors); }
+  EIG (const ComplexMatrix& a, octave_idx_type& info,
+       bool calc_eigenvectors = true)
+    : lambda (), v ()
+  {
+    info = init (a, calc_eigenvectors);
+  }
 
-  EIG (const ComplexMatrix& a, const ComplexMatrix& b, bool calc_eigenvectors = true)
-    { init (a, b, calc_eigenvectors); }
+  EIG (const ComplexMatrix& a, const ComplexMatrix& b,
+       bool calc_eigenvectors = true)
+    : lambda (), v ()
+  {
+    init (a, b, calc_eigenvectors);
+  }
 
-  EIG (const ComplexMatrix& a, const ComplexMatrix& b, octave_idx_type& info, bool calc_eigenvectors = true)
-    { info = init (a, b, calc_eigenvectors); }
+  EIG (const ComplexMatrix& a, const ComplexMatrix& b,
+       octave_idx_type& info, bool calc_eigenvectors = true)
+    : lambda (), v ()
+  {
+    info = init (a, b, calc_eigenvectors);
+  }
 
   EIG (const EIG& a)
     : lambda (a.lambda), v (a.v) { }
@@ -93,14 +120,27 @@
   ComplexMatrix v;
 
   octave_idx_type init (const Matrix& a, bool calc_eigenvectors);
-  octave_idx_type init (const Matrix& a, const Matrix& b, bool calc_eigenvectors);
+
+  octave_idx_type init (const Matrix& a, const Matrix& b,
+                        bool calc_eigenvectors);
+
   octave_idx_type init (const ComplexMatrix& a, bool calc_eigenvectors);
-  octave_idx_type init (const ComplexMatrix& a, const ComplexMatrix& b, bool calc_eigenvectors);
+
+  octave_idx_type init (const ComplexMatrix& a, const ComplexMatrix& b,
+                        bool calc_eigenvectors);
 
   octave_idx_type symmetric_init (const Matrix& a, bool calc_eigenvectors);
-  octave_idx_type symmetric_init (const Matrix& a, const Matrix& b, bool calc_eigenvectors);
-  octave_idx_type hermitian_init (const ComplexMatrix& a, bool calc_eigenvectors);
-  octave_idx_type hermitian_init (const ComplexMatrix& a, const ComplexMatrix& b, bool calc_eigenvectors);
+
+  octave_idx_type symmetric_init (const Matrix& a, const Matrix& b,
+                                  bool calc_eigenvectors);
+
+  octave_idx_type hermitian_init (const ComplexMatrix& a,
+                                  bool calc_eigenvectors);
+
+  octave_idx_type hermitian_init (const ComplexMatrix& a,
+                                  const ComplexMatrix& b,
+                                  bool calc_eigenvectors);
+
 };
 
 #endif
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/SparseCmplxQR.cc
--- a/liboctave/SparseCmplxQR.cc	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/SparseCmplxQR.cc	Thu Jan 13 02:37:45 2011 -0500
@@ -49,7 +49,8 @@
 #endif
 
 SparseComplexQR::SparseComplexQR_rep::SparseComplexQR_rep 
-(GCC_ATTR_UNUSED const SparseComplexMatrix& a, GCC_ATTR_UNUSED int order)
+  (GCC_ATTR_UNUSED const SparseComplexMatrix& a, GCC_ATTR_UNUSED int order)
+  : count (1), nrows (0), N (0), S (0)
 {
 #ifdef HAVE_CXSPARSE
   CXSPARSE_ZNAME () A;
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/SparseQR.cc
--- a/liboctave/SparseQR.cc	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/SparseQR.cc	Thu Jan 13 02:37:45 2011 -0500
@@ -30,6 +30,7 @@
 #include "oct-locbuf.h"
 
 SparseQR::SparseQR_rep::SparseQR_rep (const SparseMatrix& a, int order)
+  : count (1), nrows (0), N (0), S (0)
 {
 #ifdef HAVE_CXSPARSE
   CXSPARSE_DNAME () A;
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/dbleCHOL.h
--- a/liboctave/dbleCHOL.h	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/dbleCHOL.h	Thu Jan 13 02:37:45 2011 -0500
@@ -36,12 +36,19 @@
 {
 public:
 
-  CHOL (void) : chol_mat () { }
+  CHOL (void) : chol_mat (), xrcond (0) { }
 
-  CHOL (const Matrix& a, bool calc_cond = false) { init (a, calc_cond); }
+  CHOL (const Matrix& a, bool calc_cond = false)
+    : chol_mat (), xrcond (0)
+    {
+      init (a, calc_cond);
+    }
 
   CHOL (const Matrix& a, octave_idx_type& info, bool calc_cond = false) 
-    { info = init (a, calc_cond); }
+    : chol_mat (), xrcond (0)
+    {
+      info = init (a, calc_cond);
+    }
 
   CHOL (const CHOL& a) : chol_mat (a.chol_mat), xrcond (a.xrcond) { }
 
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/dbleGEPBAL.h
--- a/liboctave/dbleGEPBAL.h	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/dbleGEPBAL.h	Thu Jan 13 02:37:45 2011 -0500
@@ -35,16 +35,20 @@
 {
 public:
 
-  GEPBALANCE (void) : balanced_mat (), balancing_mat () { }
+  GEPBALANCE (void)
+    : balanced_mat (), balanced_mat2 (), balancing_mat (), balancing_mat2 ()
+    { }
 
   GEPBALANCE (const Matrix& a, const Matrix& b, const std::string& balance_job)
+    : balanced_mat (), balanced_mat2 (), balancing_mat (), balancing_mat2 ()
     {
       init (a, b, balance_job); 
     }
 
   GEPBALANCE (const GEPBALANCE& a)
     : balanced_mat (a.balanced_mat), balanced_mat2 (a.balanced_mat2),
-    balancing_mat (a.balancing_mat), balancing_mat2 (a.balancing_mat2) { }
+      balancing_mat (a.balancing_mat), balancing_mat2 (a.balancing_mat2)
+    { }
 
   GEPBALANCE& operator = (const GEPBALANCE& a)
     {
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/dbleHESS.h
--- a/liboctave/dbleHESS.h	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/dbleHESS.h	Thu Jan 13 02:37:45 2011 -0500
@@ -36,9 +36,13 @@
 
   HESS (void) : hess_mat (), unitary_hess_mat () { }
 
-  HESS (const Matrix& a) { init (a); }
+  HESS (const Matrix& a) : hess_mat (), unitary_hess_mat () { init (a); }
 
-  HESS (const Matrix& a, octave_idx_type& info) { info = init (a); }
+  HESS (const Matrix& a, octave_idx_type& info)
+    : hess_mat (), unitary_hess_mat ()
+    {
+      info = init (a);
+    }
 
   HESS (const HESS& a)
     : hess_mat (a.hess_mat), unitary_hess_mat (a.unitary_hess_mat) { }
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/dbleSCHUR.cc
--- a/liboctave/dbleSCHUR.cc	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/dbleSCHUR.cc	Thu Jan 13 02:37:45 2011 -0500
@@ -158,7 +158,7 @@
 }
 
 SCHUR::SCHUR (const Matrix& s, const Matrix& u)
-: schur_mat (s), unitary_mat (u)
+  : schur_mat (s), unitary_mat (u), selector (0)
 {
   octave_idx_type n = s.rows ();
   if (s.columns () != n || u.rows () != n || u.columns () != n)
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/dbleSCHUR.h
--- a/liboctave/dbleSCHUR.h	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/dbleSCHUR.h	Thu Jan 13 02:37:45 2011 -0500
@@ -35,18 +35,24 @@
 {
 public:
 
-  SCHUR (void)
-    : schur_mat (), unitary_mat () { }
+  SCHUR (void) : schur_mat (), unitary_mat (), selector (0) { }
 
   SCHUR (const Matrix& a, const std::string& ord, bool calc_unitary = true)
-    : schur_mat (), unitary_mat () { init (a, ord, calc_unitary); }
+    : schur_mat (), unitary_mat (), selector (0)
+    {
+      init (a, ord, calc_unitary);
+    }
 
   SCHUR (const Matrix& a, const std::string& ord, int& info, 
          bool calc_unitary = true)
-    : schur_mat (), unitary_mat () { info = init (a, ord, calc_unitary); }
+    : schur_mat (), unitary_mat (), selector (0)
+    {
+      info = init (a, ord, calc_unitary);
+    }
 
   SCHUR (const SCHUR& a)
-    : schur_mat (a.schur_mat), unitary_mat (a.unitary_mat) { }
+    : schur_mat (a.schur_mat), unitary_mat (a.unitary_mat), selector (0)
+    { }
 
   SCHUR (const Matrix& s, const Matrix& u);
 
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/dbleSVD.h
--- a/liboctave/dbleSVD.h	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/dbleSVD.h	Thu Jan 13 02:37:45 2011 -0500
@@ -48,21 +48,26 @@
       GESDD
     };
 
-  SVD (void) : sigma (), left_sm (), right_sm () { }
+  SVD (void) : type_computed (), sigma (), left_sm (), right_sm () { }
 
   SVD (const Matrix& a, 
        type svd_type = SVD::std, driver svd_driver = SVD::GESVD) 
-    { init (a, svd_type, svd_driver); }
+    : type_computed (), sigma (), left_sm (), right_sm ()
+    {
+      init (a, svd_type, svd_driver);
+    }
 
   SVD (const Matrix& a, octave_idx_type& info, 
        type svd_type = SVD::std, driver svd_driver = SVD::GESVD) 
+    : type_computed (), sigma (), left_sm (), right_sm ()
     {
       info = init (a, svd_type, svd_driver);
     }
 
   SVD (const SVD& a)
-    : type_computed (a.type_computed),
-      sigma (a.sigma), left_sm (a.left_sm), right_sm (a.right_sm) { }
+    : type_computed (a.type_computed), sigma (a.sigma),
+      left_sm (a.left_sm), right_sm (a.right_sm)
+    { }
 
   SVD& operator = (const SVD& a)
     {
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/fCmplxCHOL.h
--- a/liboctave/fCmplxCHOL.h	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/fCmplxCHOL.h	Thu Jan 13 02:37:45 2011 -0500
@@ -36,11 +36,17 @@
 {
 public:
 
-  FloatComplexCHOL (void) : chol_mat () { }
+  FloatComplexCHOL (void) : chol_mat (), xrcond (0) { }
 
-  FloatComplexCHOL (const FloatComplexMatrix& a, bool calc_cond = false) { init (a, calc_cond); }
+  FloatComplexCHOL (const FloatComplexMatrix& a, bool calc_cond = false)
+    : chol_mat (), xrcond (0)
+    {
+      init (a, calc_cond);
+    }
 
-  FloatComplexCHOL (const FloatComplexMatrix& a, octave_idx_type& info, bool calc_cond = false)
+  FloatComplexCHOL (const FloatComplexMatrix& a, octave_idx_type& info,
+                    bool calc_cond = false)
+    : chol_mat (), xrcond (0)
     {
       info = init (a, calc_cond);
     }
@@ -71,13 +77,15 @@
 
   octave_idx_type downdate (const FloatComplexColumnVector& u);
 
-  octave_idx_type insert_sym (const FloatComplexColumnVector& u, octave_idx_type j);
+  octave_idx_type insert_sym (const FloatComplexColumnVector& u,
+                              octave_idx_type j);
 
   void delete_sym (octave_idx_type j);
 
   void shift_sym (octave_idx_type i, octave_idx_type j);
 
-  friend OCTAVE_API std::ostream& operator << (std::ostream& os, const FloatComplexCHOL& a);
+  friend OCTAVE_API std::ostream& operator << (std::ostream& os,
+                                               const FloatComplexCHOL& a);
 
 private:
 
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/fCmplxGEPBAL.h
--- a/liboctave/fCmplxGEPBAL.h	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/fCmplxGEPBAL.h	Thu Jan 13 02:37:45 2011 -0500
@@ -36,16 +36,22 @@
 {
 public:
 
-  FloatComplexGEPBALANCE (void) : balanced_mat (), balancing_mat () { }
+  FloatComplexGEPBALANCE (void)
+    : balanced_mat (), balanced_mat2 (), balancing_mat (), balancing_mat2 ()
+    { }
 
-  FloatComplexGEPBALANCE (const FloatComplexMatrix& a, const FloatComplexMatrix& b, const std::string& balance_job)
+  FloatComplexGEPBALANCE (const FloatComplexMatrix& a,
+                          const FloatComplexMatrix& b,
+                          const std::string& balance_job)
+    : balanced_mat (), balanced_mat2 (), balancing_mat (), balancing_mat2 ()
     {
       init (a, b, balance_job); 
     }
 
   FloatComplexGEPBALANCE (const FloatComplexGEPBALANCE& a)
     : balanced_mat (a.balanced_mat), balanced_mat2 (a.balanced_mat2),
-    balancing_mat (a.balancing_mat), balancing_mat2 (a.balancing_mat2) { }
+      balancing_mat (a.balancing_mat), balancing_mat2 (a.balancing_mat2)
+    { }
 
   FloatComplexGEPBALANCE& operator = (const FloatComplexGEPBALANCE& a)
     {
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/fCmplxHESS.h
--- a/liboctave/fCmplxHESS.h	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/fCmplxHESS.h	Thu Jan 13 02:37:45 2011 -0500
@@ -36,9 +36,17 @@
 
   FloatComplexHESS (void) : hess_mat (), unitary_hess_mat () { }
 
-  FloatComplexHESS (const FloatComplexMatrix& a) { init (a); }
+  FloatComplexHESS (const FloatComplexMatrix& a)
+    : hess_mat (), unitary_hess_mat ()
+    {
+      init (a);
+    }
 
-  FloatComplexHESS (const FloatComplexMatrix& a, octave_idx_type& info) { info = init (a); }
+  FloatComplexHESS (const FloatComplexMatrix& a, octave_idx_type& info)
+    : hess_mat (), unitary_hess_mat ()
+    {
+      info = init (a);
+    }
 
   FloatComplexHESS (const FloatComplexHESS& a)
     : hess_mat (a.hess_mat), unitary_hess_mat (a.unitary_hess_mat) { }
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/fCmplxSCHUR.cc
--- a/liboctave/fCmplxSCHUR.cc	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/fCmplxSCHUR.cc	Thu Jan 13 02:37:45 2011 -0500
@@ -149,7 +149,7 @@
 
 FloatComplexSCHUR::FloatComplexSCHUR (const FloatComplexMatrix& s, 
                                       const FloatComplexMatrix& u)
-: schur_mat (s), unitary_mat (u)
+  : schur_mat (s), unitary_mat (u), selector (0)
 {
   octave_idx_type n = s.rows ();
   if (s.columns () != n || u.rows () != n || u.columns () != n)
@@ -158,7 +158,8 @@
 }
 
 FloatComplexSCHUR::FloatComplexSCHUR (const FloatSCHUR& s)
-: schur_mat (s.schur_matrix ()), unitary_mat (s.unitary_matrix ())
+  : schur_mat (s.schur_matrix ()), unitary_mat (s.unitary_matrix ()),
+    selector (0)
 {
   octave_idx_type n = schur_mat.rows ();
   if (n > 0)
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/fCmplxSCHUR.h
--- a/liboctave/fCmplxSCHUR.h	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/fCmplxSCHUR.h	Thu Jan 13 02:37:45 2011 -0500
@@ -36,19 +36,25 @@
 {
 public:
 
-  FloatComplexSCHUR (void)
-    : schur_mat (), unitary_mat () { }
+  FloatComplexSCHUR (void) : schur_mat (), unitary_mat (), selector (0) { }
 
   FloatComplexSCHUR (const FloatComplexMatrix& a, const std::string& ord,
                 bool calc_unitary = true)
-    : schur_mat (), unitary_mat () { init (a, ord, calc_unitary); }
+    : schur_mat (), unitary_mat (), selector (0)
+    {
+      init (a, ord, calc_unitary);
+    }
 
-  FloatComplexSCHUR (const FloatComplexMatrix& a, const std::string& ord, octave_idx_type& info,
-                bool calc_unitary = true)
-    : schur_mat (), unitary_mat () { info = init (a, ord, calc_unitary); }
+  FloatComplexSCHUR (const FloatComplexMatrix& a, const std::string& ord,
+                     octave_idx_type& info, bool calc_unitary = true)
+    : schur_mat (), unitary_mat (), selector (0)
+    {
+      info = init (a, ord, calc_unitary);
+    }
 
   FloatComplexSCHUR (const FloatComplexSCHUR& a)
-    : schur_mat (a.schur_mat), unitary_mat (a.unitary_mat) { }
+    : schur_mat (a.schur_mat), unitary_mat (a.unitary_mat), selector (0)
+    { }
 
   FloatComplexSCHUR (const FloatComplexMatrix& s, const FloatComplexMatrix& u);
 
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/fCmplxSVD.h
--- a/liboctave/fCmplxSVD.h	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/fCmplxSVD.h	Thu Jan 13 02:37:45 2011 -0500
@@ -36,23 +36,30 @@
 {
 public:
 
-  FloatComplexSVD (void) { }
+  FloatComplexSVD (void)
+    : type_computed (), sigma (), left_sm (), right_sm ()
+    { }
 
   FloatComplexSVD (const FloatComplexMatrix& a, 
-                   SVD::type svd_type = SVD::std, SVD::driver svd_driver = SVD::GESVD) 
+                   SVD::type svd_type = SVD::std,
+                   SVD::driver svd_driver = SVD::GESVD) 
+    : type_computed (), sigma (), left_sm (), right_sm ()
     {
       init (a, svd_type, svd_driver);
     }
 
   FloatComplexSVD (const FloatComplexMatrix& a, octave_idx_type& info,
-                   SVD::type svd_type = SVD::std, SVD::driver svd_driver = SVD::GESVD) 
+                   SVD::type svd_type = SVD::std,
+                   SVD::driver svd_driver = SVD::GESVD) 
+    : type_computed (), sigma (), left_sm (), right_sm ()
     {
       info = init (a, svd_type, svd_driver);
     }
 
   FloatComplexSVD (const FloatComplexSVD& a)
-    : type_computed (a.type_computed),
-      sigma (a.sigma), left_sm (a.left_sm), right_sm (a.right_sm) { }
+    : type_computed (a.type_computed), sigma (a.sigma),
+      left_sm (a.left_sm), right_sm (a.right_sm)
+    { }
 
   FloatComplexSVD& operator = (const FloatComplexSVD& a)
     {
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/fEIG.h
--- a/liboctave/fEIG.h	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/fEIG.h	Thu Jan 13 02:37:45 2011 -0500
@@ -43,31 +43,60 @@
     : lambda (), v () { }
 
   FloatEIG (const FloatMatrix& a, bool calc_eigenvectors = true)
-    { init (a, calc_eigenvectors); }
+    : lambda (), v ()
+  {
+    init (a, calc_eigenvectors);
+  }
 
-  FloatEIG (const FloatMatrix& a, octave_idx_type& info, bool calc_eigenvectors = true)
-    { info = init (a, calc_eigenvectors); }
+  FloatEIG (const FloatMatrix& a, octave_idx_type& info,
+            bool calc_eigenvectors = true)
+    : lambda (), v ()
+  {
+    info = init (a, calc_eigenvectors);
+  }
 
-  FloatEIG (const FloatMatrix& a, const FloatMatrix& b, bool calc_eigenvectors = true)
-    { init (a, b, calc_eigenvectors); }
+  FloatEIG (const FloatMatrix& a, const FloatMatrix& b,
+            bool calc_eigenvectors = true)
+    : lambda (), v ()
+  {
+    init (a, b, calc_eigenvectors);
+  }
 
-  FloatEIG (const FloatMatrix& a, const FloatMatrix& b, octave_idx_type& info, bool calc_eigenvectors = true)
-    { info = init (a, b, calc_eigenvectors); }
+  FloatEIG (const FloatMatrix& a, const FloatMatrix& b, octave_idx_type& info,
+            bool calc_eigenvectors = true)
+    : lambda (), v ()
+  {
+    info = init (a, b, calc_eigenvectors);
+  }
 
   FloatEIG (const FloatComplexMatrix& a, bool calc_eigenvectors = true)
-    { init (a, calc_eigenvectors); }
+    : lambda (), v ()
+  {
+    init (a, calc_eigenvectors);
+  }
 
-  FloatEIG (const FloatComplexMatrix& a, octave_idx_type& info, bool calc_eigenvectors = true)
-    { info = init (a, calc_eigenvectors); }
+  FloatEIG (const FloatComplexMatrix& a, octave_idx_type& info,
+            bool calc_eigenvectors = true)
+    : lambda (), v ()
+  {
+    info = init (a, calc_eigenvectors);
+  }
 
-  FloatEIG (const FloatComplexMatrix& a, const FloatComplexMatrix& b, bool calc_eigenvectors = true)
-    { init (a, b, calc_eigenvectors); }
+  FloatEIG (const FloatComplexMatrix& a, const FloatComplexMatrix& b,
+            bool calc_eigenvectors = true)
+    : lambda (), v ()
+  {
+    init (a, b, calc_eigenvectors);
+  }
 
-  FloatEIG (const FloatComplexMatrix& a, const FloatComplexMatrix& b, octave_idx_type& info, bool calc_eigenvectors = true)
-    { info = init (a, b, calc_eigenvectors); }
+  FloatEIG (const FloatComplexMatrix& a, const FloatComplexMatrix& b,
+            octave_idx_type& info, bool calc_eigenvectors = true)
+    : lambda (), v ()
+  {
+    info = init (a, b, calc_eigenvectors);
+  }
 
-  FloatEIG (const FloatEIG& a)
-    : lambda (a.lambda), v (a.v) { }
+  FloatEIG (const FloatEIG& a) : lambda (a.lambda), v (a.v) { }
 
   FloatEIG& operator = (const FloatEIG& a)
     {
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/floatCHOL.h
--- a/liboctave/floatCHOL.h	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/floatCHOL.h	Thu Jan 13 02:37:45 2011 -0500
@@ -36,12 +36,20 @@
 {
 public:
 
-  FloatCHOL (void) : chol_mat () { }
+  FloatCHOL (void) : chol_mat (), xrcond (0) { }
 
-  FloatCHOL (const FloatMatrix& a, bool calc_cond = false) { init (a, calc_cond); }
+  FloatCHOL (const FloatMatrix& a, bool calc_cond = false)
+    : chol_mat (), xrcond (0)
+    {
+      init (a, calc_cond);
+    }
 
-  FloatCHOL (const FloatMatrix& a, octave_idx_type& info, bool calc_cond = false) 
-    { info = init (a, calc_cond); }
+  FloatCHOL (const FloatMatrix& a, octave_idx_type& info,
+             bool calc_cond = false) 
+    : chol_mat (), xrcond (0)
+    {
+      info = init (a, calc_cond);
+    }
 
   FloatCHOL (const FloatCHOL& a) : chol_mat (a.chol_mat), xrcond (a.xrcond) { }
 
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/floatGEPBAL.h
--- a/liboctave/floatGEPBAL.h	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/floatGEPBAL.h	Thu Jan 13 02:37:45 2011 -0500
@@ -35,16 +35,19 @@
 {
 public:
 
-  FloatGEPBALANCE (void) : balanced_mat (), balancing_mat () { }
-
-  FloatGEPBALANCE (const FloatMatrix& a, const FloatMatrix& b, const std::string& balance_job)
+  FloatGEPBALANCE (void)
+    : balanced_mat (), balanced_mat2 (), balancing_mat (), balancing_mat2 ()
+    { }
+  FloatGEPBALANCE (const FloatMatrix& a, const FloatMatrix& b,
+                   const std::string& balance_job)
+    : balanced_mat (), balanced_mat2 (), balancing_mat (), balancing_mat2 ()
     {
       init (a, b, balance_job); 
     }
 
   FloatGEPBALANCE (const FloatGEPBALANCE& a)
     : balanced_mat (a.balanced_mat), balanced_mat2 (a.balanced_mat2),
-    balancing_mat (a.balancing_mat), balancing_mat2 (a.balancing_mat2) { }
+      balancing_mat (a.balancing_mat), balancing_mat2 (a.balancing_mat2) { }
 
   FloatGEPBALANCE& operator = (const FloatGEPBALANCE& a)
     {
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/floatHESS.h
--- a/liboctave/floatHESS.h	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/floatHESS.h	Thu Jan 13 02:37:45 2011 -0500
@@ -36,9 +36,17 @@
 
   FloatHESS (void) : hess_mat (), unitary_hess_mat () { }
 
-  FloatHESS (const FloatMatrix& a) { init (a); }
+  FloatHESS (const FloatMatrix& a)
+     : hess_mat (), unitary_hess_mat ()
+    {
+      init (a);
+    }
 
-  FloatHESS (const FloatMatrix& a, octave_idx_type& info) { info = init (a); }
+  FloatHESS (const FloatMatrix& a, octave_idx_type& info)
+    : hess_mat (), unitary_hess_mat ()
+    {
+      info = init (a);
+    }
 
   FloatHESS (const FloatHESS& a)
     : hess_mat (a.hess_mat), unitary_hess_mat (a.unitary_hess_mat) { }
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/floatSCHUR.cc
--- a/liboctave/floatSCHUR.cc	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/floatSCHUR.cc	Thu Jan 13 02:37:45 2011 -0500
@@ -149,7 +149,7 @@
 }
 
 FloatSCHUR::FloatSCHUR (const FloatMatrix& s, const FloatMatrix& u)
-: schur_mat (s), unitary_mat (u)
+  : schur_mat (s), unitary_mat (u), selector (0)
 {
   octave_idx_type n = s.rows ();
   if (s.columns () != n || u.rows () != n || u.columns () != n)
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/floatSCHUR.h
--- a/liboctave/floatSCHUR.h	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/floatSCHUR.h	Thu Jan 13 02:37:45 2011 -0500
@@ -35,18 +35,25 @@
 {
 public:
 
-  FloatSCHUR (void)
-    : schur_mat (), unitary_mat () { }
+  FloatSCHUR (void) : schur_mat (), unitary_mat (), selector (0) { }
 
-  FloatSCHUR (const FloatMatrix& a, const std::string& ord, bool calc_unitary = true)
-    : schur_mat (), unitary_mat () { init (a, ord, calc_unitary); }
+  FloatSCHUR (const FloatMatrix& a, const std::string& ord,
+              bool calc_unitary = true)
+    : schur_mat (), unitary_mat (), selector (0)
+    {
+      init (a, ord, calc_unitary);
+    }
 
   FloatSCHUR (const FloatMatrix& a, const std::string& ord, int& info, 
-         bool calc_unitary = true)
-    : schur_mat (), unitary_mat () { info = init (a, ord, calc_unitary); }
+              bool calc_unitary = true)
+    : schur_mat (), unitary_mat (), selector (0)
+    {
+      info = init (a, ord, calc_unitary);
+    }
 
   FloatSCHUR (const FloatSCHUR& a)
-    : schur_mat (a.schur_mat), unitary_mat (a.unitary_mat) { }
+    : schur_mat (a.schur_mat), unitary_mat (a.unitary_mat), selector (0)
+    { }
 
   FloatSCHUR (const FloatMatrix& s, const FloatMatrix& u);
 
diff -r 7bddd70bc838 -r 367bfee35ba0 liboctave/floatSVD.h
--- a/liboctave/floatSVD.h	Thu Jan 13 02:23:38 2011 -0500
+++ b/liboctave/floatSVD.h	Thu Jan 13 02:37:45 2011 -0500
@@ -36,21 +36,27 @@
 {
 public:
 
-  FloatSVD (void) : sigma (), left_sm (), right_sm () { }
+  FloatSVD (void) : type_computed (), sigma (), left_sm (), right_sm () { }
 
   FloatSVD (const FloatMatrix& a, 
             SVD::type svd_type = SVD::std, SVD::driver svd_driver = SVD::GESVD) 
-    { init (a, svd_type, svd_driver); }
+    : type_computed (), sigma (), left_sm (), right_sm ()
+    {
+      init (a, svd_type, svd_driver);
+    }
 
   FloatSVD (const FloatMatrix& a, octave_idx_type& info, 
-            SVD::type svd_type = SVD::std, SVD::driver svd_driver = SVD::GESVD) 
+            SVD::type svd_type = SVD::std,
+            SVD::driver svd_driver = SVD::GESVD) 
+    : type_computed (), sigma (), left_sm (), right_sm ()
     {
       info = init (a, svd_type, svd_driver);
     }
 
   FloatSVD (const FloatSVD& a)
-    : type_computed (a.type_computed),
-      sigma (a.sigma), left_sm (a.left_sm), right_sm (a.right_sm) { }
+    : type_computed (a.type_computed), sigma (a.sigma),
+      left_sm (a.left_sm), right_sm (a.right_sm)
+    { }
 
   FloatSVD& operator = (const FloatSVD& a)
     {