Saf/Math/Algebra/Vector.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_VECTOR_H
#define SAF_MATH_ALGEBRA_VECTOR_H

#include <math.h>
#include "../../Type.h"
#include "../../Collection/StaticArray.h"
#include "../Basic.h"
#include "../Constant.h"
#include "../Range.h"
#include "../Calculus/Powers.h"
#include "Number.h"

namespace Saf
{
    namespace Math
    {
        // @todo Vektorovy a maticovy operace jako scitani, nasobeni, pricitani skalaru apod.
        //  udelat jako obecny funkce, ktery berou vstupni a vystupni parametr, at to lze
        //  pouzivat i na zdedene tridy. Pripadne sem dat jen shortcut methods jako Gcd, Lcm, atd.

        namespace Algebra
        {
            // Forward declaration
            template <Size N, Size M, class T> class Matrix;

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

            protected:
                using BaseType::m_data;

            public:
                Vector()
                {}

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

                Vector(const T& v1, const T& v2)
                    : BaseType(v1,v2)
                {}

                Vector(const T& v1, const T& v2, const T& v3)
                    : BaseType(v1,v2,v3)
                {}

                Vector(const T& v1, const T& v2, const T& v3, const T& v4)
                    : BaseType(v1,v2,v3,v4)
                {}

                Vector(const MyType& v)
                {
                    *this = v;
                }

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

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

                    return *this;
                }

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

                    return *this;
                }

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

                    return *this;
                }

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

                    return *this;
                }

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

                    return *this;
                }

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

                    return *this;
                }

                MyType operator+(const MyType& v) const
                {
                    MyType nv;

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

                    return nv;
                }

                MyType operator-(const MyType& v) const
                {
                    MyType nv;

                    for (Size i = 0; i < N; i++)
                    {
                        nv.m_data[i] = m_data[i] - v.m_data[i];
                    }

                    return nv;
                }

                MyType operator*(const MyType& v) const
                {
                    MyType nv;

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

                    return nv;
                }

                MyType operator*(const T& v) const
                {
                    MyType nv;

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

                    return nv;
                }

                MyType operator/(const MyType &v) const
                {
                    MyType nv;

                    for (Size i = 0; i < N; i++)
                    {
                        nv.m_data[i] = m_data[i] / v.m_data[i];
                    }

                    return nv;
                }

                MyType operator/(const T& v) const
                {
                    MyType nv;

                    for (Size i = 0; i < N; i++)
                    {
                        nv.m_data[i] = m_data[i] / v;
                    }

                    return nv;
                }

                MyType operator-() const
                {
                    return *this * -1;
                }

                template <Size M>
                Vector<M,T> Mul(const Matrix<N,M,T> &m) const
                {
                    Vector<M,T> v;

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

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

                        v[i] = sum;
                    }

                    return v;
                }

                bool operator<(const MyType& v) const
                {
                    for (Size i = N; i-- > 0; )
                    {
                        if (m_data[i] < v.m_data[i])
                        {
                            return true;
                        }
                        else if (m_data[i] > v.m_data[i])
                        {
                            return false;
                        }
                    }

                    return false;
                }

                bool operator<=(const MyType& v) const
                {
                    for (Size i = N; i-- > 0; )
                    {
                        if (m_data[i] < v.m_data[i])
                        {
                            return true;
                        }
                        else if (m_data[i] > v.m_data[i])
                        {
                            return false;
                        }
                    }

                    return true;
                }

                bool operator>(const MyType& v) const
                {
                    return v < *this;
                }

                bool operator>=(const MyType& v) const
                {
                    return v <= *this;
                }

                template <Size M>
                Matrix<N,M,T> OuterProduct (const Vector<M,T> &v)
                {
                    Matrix<N,M,T> m;
                    Size p = 0;

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

                    return m;
                }

                T DotProduct (const MyType& v) const
                {
                    T sum = 0;

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

                    return sum;
                }

                template <Size M>
                T InnerProduct (const Matrix<N,M,T> &m, const MyType& v) const
                {
                    return Mul(m).DotProduct(v);
                }

                Matrix<1,N,T> ToRowMatrix() const
                {
                    Matrix<1,N,T> m;

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

                    return m;
                }

                Matrix<N,1,T> ToColumnMatrix() const
                {
                    Matrix<N,1,T> m;

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

                    return m;
                }

                T Length() const
                {
                    return Calculus::Sqrt(DotProduct(*this));
                }

                T Length(const Matrix<N,N,T> &m) const
                {
                    return Calculus::Sqrt(InnerProduct(m,*this));
                }

                T Angle(const MyType& v) const
                {
                    return acos(DotProduct(v) / (Length() * v.Length()));
                }

                T Angle(const MyType& v, const Matrix<N,N,T>& m) const
                {
                    return acos(InnerProduct(m,v) / (Length(m) * v.Length(m)));
                }

                MyType& Normalize()
                {
                    T len = Length();

                    for (Size i = 0; i < N; i++)
                    {
                        m_data[i] /= len;
                    }

                    return *this;
                }

                MyType Normalized() const
                {
                    MyType nv;
                    T len = Length();

                    for (Size i = 0; i < N; i++)
                    {
                        nv.m_data[i] = m_data[i] / len;
                    }

                    return nv;
                }

                template <Size CN,class CT>
                Vector<CN,CT> Convert(CT padVal = 0) const
                {
                    Vector<CN,CT> n;

                    if (CN < N)
                    {
                        for (Size i = 0; i < CN; i++)
                        {
                            n[i] = (CT)m_data[i];
                        }
                    }
                    else
                    {
                        for (Size i = 0; i < N; i++)
                        {
                            n[i] = (CT)m_data[i];
                        }
                        for (Size i = N; i < CN; i++)
                        {
                            n[i] = padVal;
                        }
                    }

                    return n;
                }

                Int8 Sgn() const
                {
                    for (Size i = N; i-- > 0; )
                    {
                        if (m_data[i] < 0)
                        {
                            return -1;
                        }
                        else if (m_data[i] > 0)
                        {
                            return 1;
                        }
                    }

                    return 0;
                }


                MyType& Fill(const T& val)
                {
                    Algo::Range::Fill(this->Begin(), this->End(), val);
                    return *this;
                }

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

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

                T Gcd() const
                {
                    return Algebra::Gcd(this->Begin(), this->End());
                }

                T Lcm() const
                {
                    return Algebra::Lcm(this->Begin(), this->End());
                }
            };

            template <Size N, class T>
            Vector<N,T> operator* (const T& val, const Vector<N,T> &v)
            {
                return v * val;
            }

            template <Size N, class T>
            Vector<N,T> operator/ (const T& val, const Vector<N,T> &v)
            {
                Vector<N,T> nv;

                for (Size i = 0; i < N; i++)
                {
                    nv[i] = val / v[i];
                }

                return nv;
            }

            template <class T>
            Vector<3,T> CrossProduct (const Vector<3,T> &v1, const Vector<3,T> &v2)
            {
                Vector<3,T> nv;

                nv[0] = v1[1] * v2[2] - v1[2] * v2[1];
                nv[1] = v1[2] * v2[0] - v1[0] * v2[2];
                nv[2] = v1[0] * v2[1] - v1[1] * v2[0];

                return nv;
            }

            template <class T>
            T ClockwiseAngle (const Vector<2,T> &v1, const Vector<2,T> &v2)
            {
                T ang = v1.Angle(v2);
                
                // Check the third coordinate of cross product
                if (v1[0] * v2[1] - v1[1] * v2[0] > 0)
                {
                    return 2 * T(Constant::Pi) - ang;
                }

                return ang;
            }
        }
    }
}

#endif