Saf/Math/Algebra/Matrix.h

Go to the documentation of this file.

/*
    This file is part of Simple Application Framework (Saf) library.
    Copyright (C) 2010 - 2012 Ondrej Danek <ondrej.danek@gmail.com>

    This library 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.

    Saf 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 Simple Application Framework library. If not, 
    see <http://www.gnu.org/licenses/>.
*/

#ifndef SAF_MATH_ALGEBRA_MATRIX_H
#define SAF_MATH_ALGEBRA_MATRIX_H

#include "../../Type.h"
#include "../../Collection/StaticArray.h"
#include "../Range.h"

namespace Saf
{
    namespace Math
    {
        namespace Algebra
        {
            // Forward declaration
            template <Size N, class T> class Vector;

            template <Size N, Size M, class T>
            class Matrix
                : public Collection::StaticArray<N*M,T>
            {
            protected:
                typedef Collection::StaticArray<N*M,T> BaseType;
                typedef Matrix<N,M,T> MyType;

            protected:
                using BaseType::m_data;

            public:
                Matrix()
                {}

                explicit Matrix(const T &v)
                    : BaseType(v)
                {}

                Matrix(const MyType& m)
                {
                    *this = m;
                }

                MyType& operator=(const MyType& m)
                {
                    BaseType::operator=(m);
                    return *this;
                }

                Size Rows() const
                {
                    return N;
                }

                Size Columns() const
                {
                    return M;
                }

                T& operator()(Size i, Size j)
                {
                    return m_data[i * M + j];
                }

                const T& operator()(Size i, Size j) const
                {
                    return m_data[i * M + j];
                }

                Matrix<M,N,T> Transpose() const
                {
                    Matrix<M,N,T> m;
                    Size p1 = 0, p2;

                    for (Size i = 0; i < N; i++)
                    {
                        p2 = i;

                        for (Size j = 0; j < M; j++, p1++, p2 += N)
                        {
                            m[p2] = m_data[p1];
                        }
                    }

                    return m;
                }

                MyType operator-(const MyType& m) const
                {
                    MyType n;

                    for (Size i = 0; i < N * M; ++i)
                    {
                        n.m_data[i] = m_data[i] - m.m_data[i];
                    }

                    return n;
                }

                MyType& operator-=(const MyType& m)
                {
                    for (Size i = 0; i < N * M; ++i)
                    {
                        m_data[i] -= m.m_data[i];
                    }

                    return *this;
                }

                MyType operator+(const MyType& m) const
                {
                    MyType n;

                    for (Size i = 0; i < N * M; ++i)
                    {
                        n.m_data[i] = m_data[i] + m.m_data[i];
                    }

                    return n;
                }

                MyType& operator+=(const MyType& m)
                {
                    for (Size i = 0; i < N * M; ++i)
                    {
                        m_data[i] += m.m_data[i];
                    }

                    return *this;
                }

                MyType operator*(const MyType& m) const
                {
                    MyType n;

                    for (Size i = 0; i < N * M; ++i)
                    {
                        n.m_data[i] = m_data[i] * m.m_data[i];
                    }

                    return n;
                }

                MyType& operator*=(const MyType& m)
                {
                    for (Size i = 0; i < N * M; ++i)
                    {
                        m_data[i] *= m.m_data[i];
                    }

                    return *this;
                }

                MyType operator/(const MyType& m) const
                {
                    MyType n;

                    for (Size i = 0; i < N * M; ++i)
                    {
                        n.m_data[i] = m_data[i] * m.m_data[i];
                    }

                    return n;
                }

                MyType& operator/=(const MyType& m)
                {
                    for (Size i = 0; i < N * M; ++i)
                    {
                        m_data[i] /= m.m_data[i];
                    }

                    return *this;
                }

                MyType operator*(T v) const
                {
                    MyType n;

                    for (Size i = 0; i < N * M; ++i)
                    {
                        n.m_data[i] = m_data[i] * v;
                    }

                    return n;
                }

                MyType& operator*=(T v)
                {
                    for (Size i = 0; i < N * M; ++i)
                    {
                        m_data[i] *= v;
                    }

                    return *this;
                }

                MyType operator/(T v) const
                {
                    MyType n;

                    for (Size i = N * M; i-- > 0; )
                    {
                        n.m_data[i] = m_data[i] / v;
                    }

                    return n;
                }

                MyType& operator/=(T v)
                {
                    for (Size i = N * M; i-- > 0; )
                    {
                        m_data[i] /= v;
                    }

                    return *this;
                }

                T Sum() const
                {
                    return Range::Sum(this->Begin(), this->End());
                }

                T Product() const
                {
                    return Range::Product(this->Begin(), this->End());
                }

                Vector<M,T> Row(Size r) const
                {
                    Vector<M,T> v;
                    Size p = r * M;

                    for (Size i = 0; i < M; i++, p++)
                    {
                        v[i] = m_data[p];
                    }

                    return v;
                }

                MyType& SetRow(Size r, const Vector<M,T> &v)
                {
                    Size p = r * M;

                    for (Size i = 0; i < M; i++, p++)
                    {
                        m_data[p] = v[i];
                    }

                    return *this;
                }

                Vector<N,T> Column(Size c) const
                {
                    Vector<N,T> v;
                    Size p = c;

                    for (Size i = 0; i < M; i++, p += M)
                    {
                        v[i] = m_data[p];
                    }

                    return v;
                }

                MyType& SetColumn(Size c, const Vector<N,T> &v)
                {
                    Size p = c;

                    for (Size i = 0; i < N; i++, p += M)
                    {
                        m_data[p] = v[i];
                    }

                    return *this;
                }

                template <Size K>
                Matrix<N,K,T> Mul(const Matrix<M,K,T> &m) const
                {
                    Matrix<N,K,T> n;
                    Size p3 = 0;

                    for (Size i = 0; i < N; i++)
                    {
                        for (Size j = 0; j < K; j++)
                        {
                            Size p1 = i * M, p2 = j;
                            T sum = 0;

                            for (Size k = 0; k < M; k++)
                            {
                                sum += m_data[p1] * m[p2];
                                
                                p1++;
                                p2 += K;
                            }

                            n[p3++] = sum;
                        }
                    }

                    return n;
                }

                Vector<N,T> Mul(const Vector<M,T> &v) const
                {
                    Vector<N,T> w;

                    for (Size i = 0; i < N; i++)
                    {
                        Size p = i * M;
                        T sum = 0;

                        for (Size k = 0; k < M; k++, p++)
                        {
                            sum += m_data[p] * v[k];
                        }

                        w[i] = sum;
                    }

                    return w;
                }

                MyType& SetZero()
                {
                    Algo::Range::Fill(this->Begin(), this->End(), 0);
                    return *this;
                }
            };

            template <Size N, Size M, class T>
            Matrix<N,M,T> operator*(const T &v, const Matrix<N,M,T> &m)
            {
                return m * v;
            }

            template <Size N, Size M, class T>
            Matrix<N,M,T> operator/(const T &v, const Matrix<N,M,T> &m)
            {
                Matrix<N,M,T> n;

                for (Size i = 0; i < N * M; ++i)
                {
                    n[i] = v / m[i];
                }

                return n;
            }
        }
    }
}

#endif