MathMatrix.h
/*
* Copyright (C) 2010 Regents of the University of Michigan
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MATHMATRIX_H__
#define __MATHMATRIX_H__
#include "MathVector.h"
#include "Error.h"
#include <stdio.h>
class ColumnExtras
{
private:
bool dirty;
int precision, width;
void Init();
void Copy(ColumnExtras & c);
public:
String label;
ColumnExtras()
{
Init();
}
ColumnExtras(ColumnExtras & original)
{
Init();
Copy(original);
}
~ColumnExtras();
void SetLabel(const char * name);
void SetPrecision(int p)
{
precision = p;
dirty = true;
}
void SetWidth(int w)
{
width = w;
dirty = true;
}
int GetWidth();
int GetPrecision()
{
return precision;
}
ColumnExtras & operator = (ColumnExtras & rhs)
{
Copy(rhs);
return (*this);
}
void Swap(ColumnExtras & rhs);
};
class Matrix
{
public:
String label;
ColumnExtras * extras;
int rows, cols, size, extraSize;
Vector ** data;
Matrix()
{
Init();
}
Matrix(Matrix & m)
{
Init();
Copy(m);
}
Matrix(Matrix & m, const char * name)
{
Init();
Copy(m);
SetLabel(name);
}
Matrix(int n, int m)
{
Init();
Dimension(n, m);
}
Matrix(const char * name)
{
Init();
SetLabel(name);
}
Matrix(const char * name, int n, int m)
{
Init();
Dimension(n, m);
SetLabel(name);
}
~Matrix();
void Dimension(int m, int n);
void Dimension(int m, int n, double value);
void GrowTo(int m, int n)
{
Dimension(m > rows ? m : rows, n > cols ? n : cols);
}
void GrowTo(int m, int n, double value)
{
Dimension(m > rows ? m : rows, n > cols ? n : cols, value);
}
void SetLabel(const char * name);
void SetColumnLabel(int n, const char * name)
{
extras[n].SetLabel(name);
}
const char * GetColumnLabel(int n)
{
return extras[n].label;
}
void SetColWidth(int n, int w)
{
extras[n].SetWidth(w);
}
void SetColPrecision(int n, int p)
{
extras[n].SetPrecision(p);
}
void CopyLabels(Matrix & m);
void Negate();
void Identity();
void Zero();
void Set(double k);
void Copy(const Matrix & m);
void Transpose(const Matrix & m);
void Add(const Matrix & m);
void AddMultiple(double k, const Matrix & m);
void Product(const Matrix & left, const Matrix & right);
void Add(double k);
void Multiply(double k);
// Reduces a matrix to row echelon form, assuming
// values smaller than tol are zero
void Reduce(double tol = 0.0);
Vector & operator [](int i)
{
assert(i < rows);
return *(data[i]);
}
const Vector & operator [](int i) const
{
assert(i < rows);
return *(data[i]);
}
void DeleteRow(int r);
void DeleteColumn(int c);
void SwapRows(int r1, int r2)
{
Vector * temp = data[r1];
data[r1] = data[r2];
data[r2] = temp;
};
void SwapColumns(int c1, int c2);
void MultiplyRow(int r1, double k);
void AddRows(int r1, int r2);
void AddRows(double k, int r1, int r2);
// Sort according to numeric values in the first column
void Sort();
void Print(FILE * f, int maxRows = -1, int maxCols = -1);
void PrintUpper(FILE * f, int maxRows = -1, int maxCols = -1, bool print_diag = false);
void PrintLower(FILE * f, int maxRows = -1, int maxCols = -1, bool print_diag = false);
void SetupPrint(FILE *f, int r, int c, int & column_zero, int * precision, int * width);
void Read(FILE * f);
Matrix & operator = (const Matrix & rhs)
{
Copy(rhs);
return *this;
}
bool operator == (const Matrix & rhs) const;
bool operator != (const Matrix & rhs) const
{
return !(*this == rhs);
}
Matrix & operator *= (double rhs)
{
Multiply(rhs);
return *this;
}
Matrix & operator /= (double rhs)
{
Multiply(1.0/rhs);
return *this;
}
// Stack a matrix to the bottom of the current matrix
void StackBottom(const Matrix & m);
// Stack a matrix to the left of the current matrix
void StackLeft(const Matrix & m);
// Swap dynamic allocation for two matrices
void Swap(Matrix & m);
// Functions that calculate basic summary statistics
double Min() const;
double Max() const;
double Mean() const;
// Functions that calculate summary statistics in the presence of missing data
double SafeMin() const;
double SafeMax() const;
double SafeMean() const;
int SafeCount() const;
// Return the last row in matrix
Vector & Last()
{
return *(data[rows - 1]);
}
private:
static int alloc;
static int CompareRows(Vector ** row1, Vector ** row2);
void Init();
};
#endif
Matrix
Definition: MathMatrix.h:76
ColumnExtras
Definition: MathMatrix.h:26
String
Definition: StringBasics.h:38
Vector
Definition: MathVector.h:28