Vector.hpp

Go to the documentation of this file.

#ifndef SPIDAR_VECTOR_HPP
#define SPIDAR_VECTOR_HPP

#include <cmath>
#include <string>

namespace Spidar
{
namespace Math
{
template <class T, size_t N>
struct Vector
{
    typedef T ValueType;                
 
    static const size_t size = N;       

    ValueType element[N];               

    // コンストラクタ
    Vector(void)
    {
        for (size_t i=0; i<N; ++i)  element[i] = static_cast<ValueType>(0);
    }

    Vector(const Vector& other)
    {
        for (size_t i=0; i<N; ++i)  element[i] = other.element[i];
    }

    explicit Vector(int value)
    {
        for (size_t i=0; i<N; ++i)  element[i] = static_cast<ValueType>(value);
    }

    Vector(const ValueType (&other)[N])
    {
        for (size_t i=0; i<N; ++i)  element[i] = other[i];
    }

    template <class OtherType>
    explicit Vector(const OtherType& other)
    {
         for (size_t i=0; i<N; ++i)  element[i] = static_cast<ValueType>(other.element[i]);
    }

    explicit Vector(ValueType x, ValueType y, ValueType z)
    {
        static_assert(N==3, "N is not 3");

        this->x() = static_cast<ValueType>(x);
        this->y() = static_cast<ValueType>(y);
        this->z() = static_cast<ValueType>(z);
    }

    Vector& operator=(const Vector& other)
    {
        for (size_t i=0; i<N; ++i)  element[i] = other.element[i];
        return *this;
    }

    ValueType& operator[](size_t i)
    {
        return element[i];
    }

    const ValueType& operator[](size_t i) const
    {
        return element[i];
    }

    //
    bool operator==(const Vector& other) const
    {
        for (size_t i=0; i<N; ++i)
        {
            if (element[i] != other.element[i]) return false;
        }
        return true;
    }

    //
    bool operator!=(const Vector& other) const
    {
        if (*this==other)   return false;
        else                return true;
    }

    //
    Vector& operator+=(const Vector& other)
    {
        for (size_t i=0; i<N; ++i)   element[i] += other.element[i];
        return *this;
    }

    //
    Vector& operator-=(const Vector& other)
    {
        for (size_t i=0; i<N; ++i)   element[i] -= other.element[i];
        return *this;
    }

    //
    Vector& operator*=(double value)
    {
        for (size_t i=0; i<N; ++i)   element[i] = static_cast<ValueType>(value * element[i]);
        return *this;
    }

    //
    Vector& operator/=(double value)
    {
        for (size_t i=0; i<N; ++i)   element[i] = static_cast<ValueType>(element[i] / value);
        return *this;
    }

    //
    void clear(void)
    {
        for (size_t i=0; i<N; ++i)   element[i] = static_cast<ValueType>(0);
    }

    //
    ValueType dot(const Vector& other) const
    {
        ValueType temp = 0;

        for (size_t i=0; i<N; ++i)
        {
            temp += element[i] * other.element[i];
        }
        return temp;
    }

    //
    Vector cross(const Vector& other) const
    {
        static_assert(N==3, "N is not 3");

        Vector temp;

        temp.x() = static_cast<ValueType>(y() * other.z() - z() * other.y());
        temp.y() = static_cast<ValueType>(z() * other.x() - x() * other.z());
        temp.z() = static_cast<ValueType>(x() * other.y() - y() * other.x());

        return temp;
    }

    //
    ValueType norm(void) const
    {
        return static_cast<ValueType>(std::sqrt(static_cast<double>(dot(*this))));
    }

    //
    Vector unit(void) const
    {
        return *this / norm();
    }

    //
    ValueType& x(void)
    {
        static_assert(N==3, "N is not 3");

        return element[0];
    }

    const ValueType& x(void) const
    {
        static_assert(N==3, "N is not 3");

        return element[0];
    }

    //
    ValueType& y(void)
    {
        static_assert(N==3, "N is not 3");

        return element[1];
    }

    const ValueType& y(void) const
    {
        static_assert(N==3, "N is not 3");

        return element[1];
    }

    //
    ValueType& z(void)
    {
        static_assert(N==3, "N is not 3");

        return element[2];
    }

    const ValueType& z(void) const
    {
        static_assert(N==3, "N is not 3");

        return element[2];
    }

}; // end of struct Vector.

//
template <class T, size_t N>
std::ostream& operator<<(std::ostream& os, const Vector<T,N>& v)
{
    os << "(";
    for (size_t i=0; i<N; ++i)
    {
        os << v.element[i];
        if (i<N-1) os << " ";
    }

    os << ")";

    return os;
}

// 
template <class T, size_t N>
const Vector<T,N> operator+(Vector<T,N> lhs, const Vector<T,N>& rhs)
{    
    return lhs += rhs;
}

// 
template <class T, size_t N>
const Vector<T,N> operator-(Vector<T,N> lhs, const Vector<T,N>& rhs)
{
    return lhs -= rhs;
}

// 
template <class T, size_t N>
const Vector<T,N> operator*(Vector<T,N> lhs, double rhs)
{   
    return lhs *= rhs;
}

// 
template <class T, size_t N>
const Vector<T,N> operator*(double lhs, Vector<T,N> rhs)
{
    return rhs *= lhs;
}

// 
template <class T, size_t N>
const Vector<T,N> operator/(Vector<T,N> lhs, double rhs)
{   
    return lhs /= rhs;
}

//
template <class T, size_t N>
const Vector<T,N> lerp(const Vector<T,N>& from, const Vector<T,N>& to, double t)
{
    typedef Vector<T,N> VectorType;
    typedef typename VectorType::ValueType ValueType;

    VectorType v;
    
    for (size_t i=0; i<N; ++i)
    {
        v.element[i] = static_cast<ValueType>((1.0-t) * from.element[i] + t * to.element[i]);
    }
    return v;
}

} // end of namespace Math.
} // end of namespace Spidar.

#endif // SPIDAR_VECTOR_HPP

// end of file.