Matrix.h

Go to the documentation of this file.

/******************************************************************************************************
 * (C) 2016 markummitchell@github.com. This file is part of Engauge Digitizer, which is released      *
 * under GNU General Public License version 2 (GPLv2) or (at your option) any later version. See file *
 * LICENSE or go to gnu.org/licenses for details. Distribution requires prior written permission.     *
 ******************************************************************************************************/
 
#ifndef MATRIX_H
#define MATRIX_H
 
#include <QString>
#include <QVector>
 
enum MatrixConsistent {
  MATRIX_CONSISTENT,
  MATRIX_INCONSISTENT
};
 
class Matrix
{
public:
  Matrix(int N);
 
  Matrix (int rows, int cols);
  
  Matrix (const Matrix &other);
 
  Matrix &operator= (const Matrix &matrix);
 
  int cols () const;
  
  double determinant () const;
 
  double get (int row, int col) const;
 
  Matrix inverse (int significantDigits,
                  MatrixConsistent &matrixConsistent) const;
 
  Matrix minorReduced (int rowOmit, int colOmit) const;
  
  Matrix operator* (const Matrix &other) const;
 
  QVector<double> operator* (const QVector<double> other) const;
 
  int rows () const;
 
  void set (int row, int col, double value);
 
  QString toString () const;
 
  Matrix transpose () const;
  
private:
  Matrix();
 
  void addRowToAnotherWithScaling (int rowFrom,
                                   int rowTo,
                                   double factor);
  int fold2dIndexes (int row, int col) const;
  void initialize (int rows,
                   int cols);
  Matrix inverseCramersRule (MatrixConsistent &matrixConsistent,
                             double epsilonThreshold) const;
  Matrix inverseGaussianElimination (int significantDigits,
                                     MatrixConsistent &matrixConsistent) const;
  unsigned int leadingZeros (int row) const; // Number of leading zeros in the specified zero
  void normalizeRow (int rowToNormalize,
                     int colToNormalize,
                     int significantDigits,
                     MatrixConsistent &matrixConsistent);
  void switchRows (int row1,
                   int row2);
 
  // Return true if value is sufficiently far from zero that we can divide by it as part of
  // calculating a matrix inverse. The epsilon threshold is proportional to the largest value in the
  // matrix since a good threshold of 1e-8 for matrix elements near 1 should be scaled to
  // 1e-18 for matrix elements near 1e-10
  bool valueFailsEpsilonTest (double value,
                              double epsilonThreshold) const;
 
  int m_rows; // Height of matrix
  int m_cols; // Width of matrix
  QVector<double> m_vector;
};
 
#endif // MATRIX_H