matrix.inl

Go to the documentation of this file.

/*
    Sheep - A Rigid Body Dynamics Engine
    Copyright (C) 2001-2004 Francois Beaune
    Contact: http://toxicengine.sourceforge.net/

    This file is part of Sheep.

    Sheep 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 2 of the License, or
    (at your option) any later version.

    Sheep 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 Sheep; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

//!\todo Optimize by precomputing and storing m_r * m_c in the matrix.
#define LOOP(OP) for(int i = 0; i < m_r * m_c; i++) OP;

inline
Matrix::Matrix(int rows, int columns) {
    assert(rows > 0);
    assert(columns > 0);

    m_r = rows;
    m_c = columns;

    m_v = new Real[m_r * m_c];
}

inline
Matrix::Matrix(int rows, int columns, Real r) {
    assert(rows > 0);
    assert(columns > 0);

    m_r = rows;
    m_c = columns;

    m_v = new Real[m_r * m_c];

    LOOP(m_v[i] = r);
}

inline
Matrix::Matrix(const Matrix &m) {
    m_r = m.m_r;
    m_c = m.m_c;

    m_v = new Real[m_r * m_c];

    LOOP(m_v[i] = m.m_v[i]);
}

inline
Matrix::~Matrix() {
    delete [] m_v;
}

inline
Matrix Matrix::Identity(int n) {
    Matrix res(n, n, 0);

    Real *v = res.m_v;

    for(int i = 0; i < n; i++, v += n + 1)
        *v = 1;

    return res;
}

inline
Matrix &Matrix::operator=(Real r) {
    LOOP(m_v[i] = r);

    return *this;
}

inline
Matrix &Matrix::operator=(const Matrix &m) {
    assert(m_r == m.m_r);
    assert(m_c == m.m_c);

    LOOP(m_v[i] = m.m_v[i]);

    return *this;
}

inline
int Matrix::GetRows() const {
    return m_r;
}

inline
int Matrix::GetColumns() const {
    return m_c;
}

inline
bool Matrix::IsSquare() const {
    return m_r == m_c;
}

inline
Matrix Matrix::operator+(const Matrix &m) const {
    assert(m_r == m.m_r);
    assert(m_c == m.m_c);

    Matrix res(m_r, m_c);

    LOOP(res.m_v[i] = m_v[i] + m.m_v[i]);

    return res;
}

inline
Matrix Matrix::operator-(const Matrix &m) const {
    assert(m_r == m.m_r);
    assert(m_c == m.m_c);

    Matrix res(m_r, m_c);

    LOOP(res.m_v[i] = m_v[i] - m.m_v[i]);

    return res;
}

inline
Matrix Matrix::operator-() const {
    Matrix res(m_r, m_c);

    LOOP(res.m_v[i] = -m_v[i]);

    return res;
}

inline
Matrix Matrix::operator*(Real r) const {
    Matrix res(m_r, m_c);

    LOOP(res.m_v[i] = m_v[i] * r);

    return res;
}

inline
Matrix Matrix::operator/(Real r) const {
    Matrix res(m_r, m_c);

    LOOP(res.m_v[i] = m_v[i] / r);

    return res;
}

inline
Matrix &Matrix::operator+=(const Matrix &m) {
    assert(m_r == m.m_r);
    assert(m_c == m.m_c);

    LOOP(m_v[i] += m.m_v[i]);

    return *this;
}

inline
Matrix &Matrix::operator-=(const Matrix &m) {
    assert(m_r == m.m_r);
    assert(m_c == m.m_c);

    LOOP(m_v[i] -= m.m_v[i]);

    return *this;
}

inline
Matrix &Matrix::operator*=(Real r) {
    LOOP(m_v[i] *= r);

    return *this;
}

inline
Matrix &Matrix::operator/=(Real r) {
    LOOP(m_v[i] /= r);

    return *this;
}

inline
Real &Matrix::operator[](int i) {
    assert(i >= 0);
    assert(i < m_r * m_c);

    return m_v[i];
}

inline
const Real &Matrix::operator[](int i) const {
    assert(i >= 0);
    assert(i < m_r * m_c);

    return m_v[i];
}

inline
Real &Matrix::operator()(int row, int column) {
    assert(row >= 0);
    assert(row < m_r);
    assert(column >= 0);
    assert(column < m_c);

    return m_v[row * m_c + column];
}

inline
const Real &Matrix::operator()(int row, int column) const {
    assert(row >= 0);
    assert(row < m_r);
    assert(column >= 0);
    assert(column < m_c);

    return m_v[row * m_c + column];
}

inline
Real *Matrix::GetData() {
    return m_v;
}

inline
Real Matrix::Trace() const {
    assert(m_r == m_c);

    Real *v = m_v;
    Real res = 0;

    for(int i = 0; i < m_c; i++, v += m_c + 1)
        res += *v;

    return res;
}

inline
Matrix operator*(Real r, const Matrix &m) {
    return m * r;
}

#undef LOOP

---