if( MTX_MaxRowIndex( &m_Matrix, row, &re, &im, &col ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_MaxRowIndex returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_MaxRowVal(const unsigned row, double &re, double &im )
  {
    if( MTX_MaxRow( &m_Matrix, row, &re, &im ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_MaxRow returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_MinAbs(unsigned &row, unsigned &col, double &value )
  {
    if( MTX_MinAbsIndex( &m_Matrix, &value, &row, &col ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_MinAbsIndex returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_Min(unsigned &row, unsigned &col, double &re, double &im )
  {
    if( MTX_MinIndex( &m_Matrix, &re, &im, &row, &col ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_MinIndex returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_MinVal(double &re, double &im )
  {
    if( MTX_Min( &m_Matrix, &re, &im ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Min returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_MinAbsCol(const unsigned col, double &value, unsigned &row )
  {
    if( MTX_MinAbsColIndex( &m_Matrix, col, &value, &row ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_MinAbsColIndex returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_MinCol(const unsigned col, double &re, double &im, unsigned &row )
  {
    if( MTX_MinColIndex( &m_Matrix, col, &re, &im, &row ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_MinColIndex returned false." );
      return false;
    }
  }


  bool Matrix::GetStats_MinColVal(const unsigned col, double &re, double &im )
  {
    if( MTX_MinColumn( &m_Matrix, col, &re, &im ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_MinColumn returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_MinAbsRow(const unsigned row, double &value, unsigned &col )
  {
    if( MTX_MinAbsRowIndex( &m_Matrix, row, &value, &col ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_MinAbsRowIndex returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_MinRow(const unsigned row, double &re, double &im, unsigned &col )
  {
    if( MTX_MinRowIndex( &m_Matrix, row, &re, &im, &col ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_MinRowIndex returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_MinRowVal(const unsigned row, double &re, double &im )
  {
    if( MTX_MinRow(  &m_Matrix, row, &re, &im ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_MinRow returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_ColRange( const unsigned col, double &re, double &im )
  {
    if( MTX_ColumnRange( &m_Matrix, col, &re, &im ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_ColumnRange returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_RowRange( const unsigned row, double &re, double &im )
  {
    if( MTX_RowRange( &m_Matrix, row, &re, &im ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_RowRange returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_Range( double &re, double &im )
  {
    if( MTX_Range( &m_Matrix, &re, &im ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Range returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_ColumnSum( const unsigned col, double &re, double &im )
  {
    if( MTX_ColumnSum( &m_Matrix, col, &re, &im ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_ColumnSum returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_RowSum( const unsigned row, double &re, double &im )
  {
    if( MTX_RowSum( &m_Matrix, row, &re, &im ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_RowSum returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_Sum( double &re, double &im )
  {
    if( MTX_Sum( &m_Matrix, &re, &im ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Sum returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_ColumnMean( const unsigned col, double &re, double &im )
  {
    if( MTX_ColumnMean( &m_Matrix, col, &re, &im ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_ColumnMean returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_RowMean( const unsigned row, double &re, double &im )
  {
    if( MTX_RowMean( &m_Matrix, row, &re, &im ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_RowMean returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_Mean( double &re, double &im )
  {
    if( MTX_Mean( &m_Matrix, &re, &im ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Mean returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_ColumnStdev( const unsigned col, double &value )
  {
    if( MTX_ColumnStdev( &m_Matrix, col, &value ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_ColumnStdev returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_RowStdev( const unsigned row, double &value )
  {
    if( MTX_RowStdev( &m_Matrix, row, &value ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_RowStdev returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_Stdev( double &value )
  {
    if( MTX_Stdev( &m_Matrix, &value ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Stdev returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_ColumnVar( const unsigned col, double &value )
  {
    if( MTX_ColumnVar( &m_Matrix, col, &value ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_ColumnVar returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_RowVar( const unsigned row, double &value )
  {
    if( MTX_RowVar( &m_Matrix, row, &value ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_RowVar returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_Var( double &value )
  {
    if( MTX_Var( &m_Matrix, &value ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Var returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_ColumnNorm( const unsigned col, double &value )
  {
    if( MTX_ColumnNorm( &m_Matrix, col, &value ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_ColumnNorm returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_RowNorm( const unsigned row, double &value )
  {
    if( MTX_RowNorm( &m_Matrix, row, &value ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_RowNorm returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_Norm( double &value )
  {
    if( MTX_Norm( &m_Matrix, &value ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Norm returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_ColumnRMS( const unsigned col, double &value )
  {
    if( MTX_ColumnRMS( &m_Matrix, col, &value ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_ColumnRMS returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_RowRMS( const unsigned row, double &value )
  {
    if( MTX_RowRMS( &m_Matrix, row, &value ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_RowRMS returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_RMS( double &value )
  {
    if( MTX_RMS( &m_Matrix, &value ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_RMS returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_ColumnSkewness( const unsigned col, double &re, double &im )
  {
    if( MTX_ColumnSkewness( &m_Matrix, col, &re, &im ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_ColumnSkewness returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_RowSkewness( const unsigned row, double &re, double &im )
  {
    if( MTX_RowSkewness( &m_Matrix, row, &re, &im ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_RowSkewness returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_Skewness( double &re, double &im )
  {
    if( MTX_Skewness( &m_Matrix, &re, &im ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Skewness returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_ColumnKurtosis( const unsigned col, double &re, double &im )
  {
    if( MTX_ColumnKurtosis( &m_Matrix, col, &re, &im ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_ColumnKurtosis returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_RowKurtosis( const unsigned row, double &re, double &im )
  {
    if( MTX_RowKurtosis( &m_Matrix, row, &re, &im ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_RowKurtosis returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_Kurtosis( double &re, double &im )
  {
    if( MTX_Kurtosis( &m_Matrix, &re, &im ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Kurtosis returned false." );
      return false;
    }
  }

  bool Matrix::GetTrace( double &re, double &im )
  {
    if( MTX_Trace( &m_Matrix, &re, &im ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Trace returned false." );
      return false;
    }
  }

  bool Matrix::GetDeterminant( double &re, double &im )
  {
    if( MTX_Det( &m_Matrix, &re, &im ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Det returned false." );
      return false;
    }
  }

  bool Matrix::GetDiagonal( Matrix& DiagonalVector )
  {
    if( MTX_Diagonal( &m_Matrix, &DiagonalVector.m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Diagonal returned false." );
      return false;
    }
  }

  bool Matrix::GetColumnMovAvg( const unsigned col, const unsigned lead, const unsigned lag, Matrix &MovAvg )
  {
    if( MTX_ColumnMovAvg( &m_Matrix, col, lead, lag, &MovAvg.m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_ColumnMovAvg returned false." );
      return false;
    }
  }

  bool Matrix::GetMovAvg( const unsigned lead, const unsigned lag, Matrix &MovAvg )
  {
    if( MTX_MovAvg( &m_Matrix, lead, lag, &MovAvg.m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_MovAvg returned false." );
      return false;
    }
  }

  bool Matrix::GetATAInverse( Matrix &InvATA )
  {
    if( MTX_ATAInverse( &m_Matrix, &InvATA.m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_ATAInverse returned false." );
      return false;
    }
  }

  bool Matrix::GetLUFactorization( bool &isFullRank, Matrix &P, Matrix &L, Matrix &U )
  {
    BOOL b_isFullRank;
    if( MTX_LUFactorization( &m_Matrix, &b_isFullRank, &P.m_Matrix, &L.m_Matrix, &U.m_Matrix ) )
    {
      if( b_isFullRank )
        isFullRank = true;
      else
        isFullRank = false;

      return true;
    }
    else 
    {
      if( b_isFullRank )
        isFullRank = true;
      else
        isFullRank = false;

      MTX_ERROR_MSG( "MTX_LUFactorization returned false." );
      return false;
    }
  }

  bool Matrix::GetLDLt( 
    Matrix& L,   //!< A unit lower triangular matrix.
    Matrix& d,   //!< The diagonal vector from the diagonal of the D matrix.
    bool checkSymmetric //!< Enforce a symmetry check. Runs faster if disabled.
    )
  {
    if( MTX_LDLt( &m_Matrix, &L.m_Matrix, &d.m_Matrix, checkSymmetric ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_LDLt returned false." );
      return false;
    }
  }

  bool Matrix::GetUDUt( 
    Matrix& U,  //!< A unit upper triangular matrix.
    Matrix& d,  //!< The diagonal vector from the diagonal of the D matrix.
    bool checkSymmetric //!< Enforce a symmetry check. Runs faster if