175 lines
5.1 KiB
C++
Executable file
175 lines
5.1 KiB
C++
Executable file
// Authors: Unknown. Please, if you are the author of this file, or if you
|
|
// know who are the authors of this file, let us know, so we can give the
|
|
// adequate credits and/or get the adequate authorizations.
|
|
|
|
#ifndef MATRIX_H
|
|
#define MATRIX_H
|
|
|
|
#include <iostream>
|
|
#include <cassert>
|
|
|
|
namespace libNumerics {
|
|
|
|
// Forward declaration, definition below
|
|
template <typename T> class vector;
|
|
template <typename T> class matrix;
|
|
|
|
template <typename T> matrix<T> cat(const matrix<T>&, const matrix<T>&);
|
|
template <typename T> void swap(matrix<T>&, matrix<T>&);
|
|
|
|
/// Matrix class
|
|
template <typename T>
|
|
class matrix
|
|
{
|
|
public:
|
|
static matrix<T> zeros(int m) { return zeros(m,m); }
|
|
static matrix<T> zeros(int m, int n);
|
|
static matrix<T> ones(int m) { return ones(m,m); }
|
|
static matrix<T> ones(int m, int n);
|
|
static matrix<T> eye(int n); ///< Identity matrix.
|
|
|
|
public:
|
|
matrix(int m, int n);
|
|
matrix(const matrix<T>& m);
|
|
virtual ~matrix();
|
|
matrix<T>& operator=(const matrix<T>& m);
|
|
|
|
int nrow() const { return m_rows; } ///< The number of rows.
|
|
int ncol() const { return m_cols; } ///< The number of columns.
|
|
T operator() (int i, int j) const;
|
|
T& operator() (int i, int j);
|
|
T operator() (int i) const;
|
|
T& operator() (int i);
|
|
|
|
void operator=(T a);
|
|
matrix<T> operator*(T a) const;
|
|
matrix<T> operator/(T a) const;
|
|
void operator*=(T a);
|
|
void operator/=(T a);
|
|
/// Product by scalar.
|
|
friend matrix<T> operator*(T a, const matrix<T>& m)
|
|
{ return m * a; }
|
|
|
|
matrix<T> operator+(const matrix<T>& m) const;
|
|
matrix<T> operator-(const matrix<T>& m) const;
|
|
matrix<T> operator-() const; ///< Matrix opposite.
|
|
matrix<T> operator*(const matrix<T>& m) const;
|
|
vector<T> operator*(const vector<T>& m) const;
|
|
|
|
void operator+=(const matrix<T>& m);
|
|
void operator-=(const matrix<T>& m);
|
|
|
|
matrix<T> t() const; ///< Transpose.
|
|
vector<T> diag() const; ///< Diagonal of matrix.
|
|
T tr() const;
|
|
T det() const;
|
|
matrix<T> inv() const;
|
|
|
|
void symUpper();
|
|
void symLower();
|
|
|
|
matrix<T> copy(int i0, int i1, int j0, int j1) const;
|
|
matrix<T> copyCols(int j0, int j1) const;
|
|
matrix<T> copyRows(int i0, int i1) const;
|
|
void paste(int i0, int j0, const matrix<T>& block);
|
|
friend matrix<T> cat<T>(const matrix<T>& left, const matrix<T>& right);
|
|
vector<T> col(int j) const; ///< Copy column.
|
|
matrix<T> row(int i) const; ///< Copy row.
|
|
int lastCol() const {return m_cols-1;} ///< Index of last column.
|
|
int lastRow() const {return m_rows-1;} ///< Index of last row.
|
|
|
|
friend void swap<T>(matrix<T>&, matrix<T>&);
|
|
void swapRows(int i0, int i1);
|
|
void swapCols(int j0, int j1);
|
|
|
|
template <typename U>
|
|
void read(const U* v);
|
|
void read(const matrix<T>& v);
|
|
void write(T* vect) const;
|
|
|
|
protected:
|
|
int m_rows; ///< Number of rows.
|
|
int m_cols; ///< Number of columns.
|
|
T* p; ///< 1-D array of coefficients.
|
|
|
|
void alloc(int m, int n); ///< Allocate the array value.
|
|
void free(); ///< Free the array value.
|
|
int nElements() const; ///< Number of elements in the matrix.
|
|
matrix<T>& sub(matrix<T>& s, int i, int j) const;
|
|
}; // class matrix
|
|
|
|
/// Column vector class (template)
|
|
template <typename T>
|
|
class vector : public matrix<T>
|
|
{
|
|
public:
|
|
explicit vector(int m);
|
|
vector(T x);
|
|
vector(T x, T y);
|
|
vector(T x, T y, T z);
|
|
vector(const vector<T>& v);
|
|
virtual ~vector() {}
|
|
using matrix<T>::operator=;
|
|
vector<T>& operator=(const vector<T>& v);
|
|
// void operator=(T a);
|
|
|
|
vector<T> operator*(T a) const;
|
|
vector<T> operator/(T a) const;
|
|
/// Product of a vector by a scalar.
|
|
friend vector<T> operator*(T a, const vector<T>& v)
|
|
{ return v * a; }
|
|
|
|
vector<T> operator+(const vector<T>& v) const;
|
|
vector<T> operator-(const vector<T>& v) const;
|
|
vector<T> operator-() const; ///< Vector opposite.
|
|
|
|
matrix<T> operator*(const matrix<T>& m) const;
|
|
matrix<T> diag() const;
|
|
T qnorm() const;
|
|
|
|
vector<T> copy(int i0, int i1) const;
|
|
void paste(int i0, const vector<T>& v);
|
|
};
|
|
|
|
} // namespace libNumerics
|
|
|
|
/// Output matrix coefficients.
|
|
template <typename T>
|
|
inline std::ostream& operator<<(std::ostream& out,
|
|
const libNumerics::matrix<T>& m)
|
|
{
|
|
for(int i = 0; i < m.nrow(); ++i) {
|
|
out << ((i==0)? "[": ";");
|
|
for (int j = 0; j < m.ncol(); ++j)
|
|
out << " " << m(i,j);
|
|
}
|
|
out << " ]";
|
|
return out;
|
|
}
|
|
|
|
/// Input matrix. Need to know the dimensions in advance...
|
|
template <class T>
|
|
inline std::istream& operator>>(std::istream& in,
|
|
libNumerics::matrix<T>& m)
|
|
{
|
|
char c;
|
|
for(int i=0; i < m.nrow(); ++i) {
|
|
in >> c;
|
|
for(int j=0; j < m.ncol(); ++j)
|
|
in >> m(i,j);
|
|
}
|
|
in >> c;
|
|
return in;
|
|
}
|
|
|
|
template <typename T>
|
|
T dot(const libNumerics::vector<T>& u, const libNumerics::vector<T>& v);
|
|
template <typename T>
|
|
libNumerics::vector<T> cross(const libNumerics::vector<T>& u,
|
|
const libNumerics::vector<T>& v);
|
|
|
|
// Need to see definitions for templates...
|
|
#include "matrix.cpp"
|
|
#include "vector.cpp"
|
|
|
|
#endif
|