Saf/Math/Algebra/SquareMatrix.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_SQUAREMATRIX_H
#define SAF_MATH_ALGEBRA_SQUAREMATRIX_H

#include "../../NotImplementedException.h"
#include "Matrix.h"

namespace Saf
{
    namespace Math
    {
        namespace Algebra
        {
            template <Size N, class T>
            class SquareMatrix
                : public Matrix<N,N,T>
            {
            protected:
                using Matrix<N,N,T>::m_data;

            public:
                SquareMatrix()
                    : Matrix<N,N,T>()
                {}

                explicit SquareMatrix(const T& val)
                    : Matrix<N,N,T>(val)
                {}

                explicit SquareMatrix(const Matrix<N,N,T>& m)
                    : Matrix<N,N,T>(m)
                {}

                explicit SquareMatrix(const Vector<N,T> &v)
                    : Matrix<N,N,T>()
                {
                    SetMainDiagonal(v);
                }

                SquareMatrix<N,T>& SetMainDiagonal(const Vector<N,T> &v)
                {
                    Algo::Range::Fill(Begin(), End(), 0);

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

                    return *this;
                }

                Vector<N,T> MainDiagonal() const
                {
                    Vector<N,T> v;
                    Size j = 0;

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

                    return v;
                }

                T Determinant() const
                {
                    if (N == 2)
                    {
                        return m_data[0] * m_data[3] - m_data[1] * m_data[2];
                    }
                    else if (N == 3)
                    {
                        return m_data[0]*m_data[4]*m_data[8] + 
                               m_data[1]*m_data[5]*m_data[6] + 
                               m_data[2]*m_data[3]*m_data[7] -
                               m_data[2]*m_data[4]*m_data[6] - 
                               m_data[1]*m_data[3]*m_data[8] - 
                               m_data[0]*m_data[5]*m_data[7];
                    }
                    else
                    {
                        throw NotImplementedException(SAF_SOURCE_LOCATION,
                            "Determinant computation implemented only for 2x2 and 3x3 matrices.");
                    }

                    return 0;
                }

                SquareMatrix<N,T>& SetIdentity()
                {
                    Algo::Range::Fill(Begin(), End(), 0);

                    Size k = 0;
                    for (Size i = 0; i < N; i++)
                    {
                        m_data[k] = T(1);
                        k += N + 1;
                    }

                    return *this;
                }

                static SquareMatrix<N,T> Identity()
                {
                    SquareMatrix<N,T> m;
                    m.SetIdentity();
                    return m;
                }
            };
        }
    }
}

#endif