Vector.hpp

Go to the documentation of this file.

/*
 * Original work Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
 * Modified work Copyright (c) 2017 Louis Langholtz https://github.com/louis-langholtz/PlayRho
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
 
#ifndef PLAYRHO_COMMON_VECTOR_HPP
#define PLAYRHO_COMMON_VECTOR_HPP
 
#include <cassert>
#include <cstddef>
#include <type_traits>
#include <iterator>
#include <algorithm>
#include <functional>
#include <iostream>
#include <PlayRho/Common/InvalidArgument.hpp>
#include <PlayRho/Common/Real.hpp>
#include <PlayRho/Common/Templates.hpp>
 
namespace playrho {
 
template <typename T, std::size_t N>
struct Vector
{
    using value_type = T;
 
    using size_type = std::size_t;
    
    using difference_type = std::ptrdiff_t;
    
    using reference = value_type&;
    
    using const_reference = const value_type&;
    
    using pointer = value_type*;
    
    using const_pointer = const value_type*;
    
    using iterator = value_type*;
    
    using const_iterator = const value_type*;
    
    using reverse_iterator = std::reverse_iterator<iterator>;
    
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
    
    PLAYRHO_CONSTEXPR inline Vector() = default;
    
    template<typename... Tail>
    PLAYRHO_CONSTEXPR inline Vector(std::enable_if_t<sizeof...(Tail)+1 == N, T> head,
                                    Tail... tail) noexcept: elements{head, T(tail)...}
    {
        // Intentionally empty.
    }
 
    PLAYRHO_CONSTEXPR inline size_type max_size() const noexcept { return N; }
    
    PLAYRHO_CONSTEXPR inline size_type size() const noexcept { return N; }
    
    PLAYRHO_CONSTEXPR inline bool empty() const noexcept { return N == 0; }
    
    iterator begin() noexcept { return iterator(elements); }
 
    iterator end() noexcept { return iterator(elements + N); }
    
    const_iterator begin() const noexcept { return const_iterator(elements); }
    
    const_iterator end() const noexcept { return const_iterator(elements + N); }
    
    const_iterator cbegin() const noexcept { return begin(); }
    
    const_iterator cend() const noexcept { return end(); }
 
    reverse_iterator rbegin() noexcept { return reverse_iterator{elements + N}; }
 
    reverse_iterator rend() noexcept { return reverse_iterator{elements}; }
    
    const_reverse_iterator crbegin() const noexcept
    {
        return const_reverse_iterator{elements + N};
    }
    
    const_reverse_iterator crend() const noexcept
    {
        return const_reverse_iterator{elements};
    }
 
    const_reverse_iterator rbegin() const noexcept
    {
        return crbegin();
    }
    
    const_reverse_iterator rend() const noexcept
    {
        return crend();
    }
 
    PLAYRHO_CONSTEXPR inline reference operator[](size_type pos) noexcept
    {
        assert(pos < size());
        return elements[pos];
    }
    
    PLAYRHO_CONSTEXPR inline const_reference operator[](size_type pos) const noexcept
    {
        assert(pos < size());
        return elements[pos];
    }
    
    PLAYRHO_CONSTEXPR inline reference at(size_type pos)
    {
        if (pos >= size())
        {
            throw InvalidArgument("Vector::at: position >= size()");
        }
        return elements[pos];
    }
    
    PLAYRHO_CONSTEXPR inline const_reference at(size_type pos) const
    {
        if (pos >= size())
        {
            throw InvalidArgument("Vector::at: position >= size()");
        }
        return elements[pos];
    }
    
    PLAYRHO_CONSTEXPR inline pointer data() noexcept
    {
        return elements;
    }
    
    PLAYRHO_CONSTEXPR inline const_pointer data() const noexcept
    {
        return elements;
    }
    
    value_type elements[N? N: 1]; // Never zero to avoid needing C++ extension capability.
};
 
 
template <typename>
struct IsVector: std::false_type {};
 
template <typename T, std::size_t N>
struct IsVector<Vector<T, N>>: std::true_type {};
 
 
template <typename T, std::size_t N>
PLAYRHO_CONSTEXPR inline bool operator== (const Vector<T, N>& lhs, const Vector<T, N>& rhs) noexcept
{
    for (auto i = decltype(N){0}; i < N; ++i)
    {
        if (lhs[i] != rhs[i])
        {
            return false;
        }
    }
    return true;
}
 
template <typename T, std::size_t N>
PLAYRHO_CONSTEXPR inline bool operator!= (const Vector<T, N>& lhs, const Vector<T, N>& rhs) noexcept
{
    return !(lhs == rhs);
}
 
template <typename T, std::size_t N>
PLAYRHO_CONSTEXPR inline
std::enable_if_t<std::is_same<T, decltype(+T{})>::value, Vector<T, N>>
operator+ (Vector<T, N> v) noexcept
{
    return v;
}
 
template <typename T, std::size_t N>
PLAYRHO_CONSTEXPR inline
std::enable_if_t<std::is_same<T, decltype(-T{})>::value, Vector<T, N>>
operator- (Vector<T, N> v) noexcept
{
    for (auto i = decltype(N){0}; i < N; ++i)
    {
        v[i] = -v[i];
    }
    return v;
}
 
template <typename T, std::size_t N>
PLAYRHO_CONSTEXPR inline
std::enable_if_t<std::is_same<T, decltype(T{} + T{})>::value, Vector<T, N>&>
operator+= (Vector<T, N>& lhs, const Vector<T, N> rhs) noexcept
{
    for (auto i = decltype(N){0}; i < N; ++i)
    {
        lhs[i] += rhs[i];
    }
    return lhs;
}
 
template <typename T, std::size_t N>
PLAYRHO_CONSTEXPR inline
std::enable_if_t<std::is_same<T, decltype(T{} - T{})>::value, Vector<T, N>&>
operator-= (Vector<T, N>& lhs, const Vector<T, N> rhs) noexcept
{
    for (auto i = decltype(N){0}; i < N; ++i)
    {
        lhs[i] -= rhs[i];
    }
    return lhs;
}
 
template <typename T, std::size_t N>
PLAYRHO_CONSTEXPR inline
std::enable_if_t<std::is_same<T, decltype(T{} + T{})>::value, Vector<T, N>>
operator+ (Vector<T, N> lhs, const Vector<T, N> rhs) noexcept
{
    return lhs += rhs;
}
 
template <typename T, std::size_t N>
PLAYRHO_CONSTEXPR inline
std::enable_if_t<std::is_same<T, decltype(T{} - T{})>::value, Vector<T, N>>
operator- (Vector<T, N> lhs, const Vector<T, N> rhs) noexcept
{
    return lhs -= rhs;
}
 
template <typename T1, typename T2, std::size_t N>
PLAYRHO_CONSTEXPR inline
std::enable_if_t<std::is_same<T1, decltype(T1{} * T2{})>::value, Vector<T1, N>&>
operator*= (Vector<T1, N>& lhs, const T2 rhs) noexcept
{
    for (auto i = decltype(N){0}; i < N; ++i)
    {
        lhs[i] *= rhs;
    }
    return lhs;
}
 
template <typename T1, typename T2, std::size_t N>
PLAYRHO_CONSTEXPR inline
std::enable_if_t<std::is_same<T1, decltype(T1{} / T2{})>::value, Vector<T1, N>&>
operator/= (Vector<T1, N>& lhs, const T2 rhs) noexcept
{
    const auto inverseRhs = Real{1} / rhs;
    for (auto i = decltype(N){0}; i < N; ++i)
    {
        lhs[i] *= inverseRhs;
    }
    return lhs;
}
 
template <typename T1, typename T2, std::size_t A, std::size_t B, std::size_t C,
    typename OT = decltype(T1{} * T2{})>
PLAYRHO_CONSTEXPR inline
std::enable_if_t<IsMultipliable<T1, T2>::value, Vector<Vector<OT, C>, A>>
operator* (const Vector<Vector<T1, B>, A>& lhs, const Vector<Vector<T2, C>, B>& rhs) noexcept
{
    //using OT = decltype(T1{} * T2{});
    auto result = Vector<Vector<OT, C>, A>{};
    for (auto a = decltype(A){0}; a < A; ++a)
    {
        for (auto c = decltype(C){0}; c < C; ++c)
        {
            // So for 2x3 lhs matrix * 3*2 rhs matrix... result is 2x2 matrix:
            // result[0][0] = lhs[0][0] * rhs[0][0] + lhs[0][1] * rhs[1][0] + lhs[0][2] * rhs[2][0]
            // result[0][1] = lhs[0][0] * rhs[0][1] + lhs[0][1] * rhs[1][1] + lhs[0][2] * rhs[2][1]
            // result[1][0] = lhs[1][0] * rhs[0][0] + lhs[1][1] * rhs[1][0] + lhs[1][2] * rhs[2][0]
            // result[1][1] = lhs[1][0] * rhs[0][1] + lhs[1][1] * rhs[1][1] + lhs[1][2] * rhs[2][1]
            // This is also: result[a][c] = row(lhs, a) * col(rhs, c)
            auto element = OT{};
            for (auto b = decltype(B){0}; b < B; ++b)
            {
                element += lhs[a][b] * rhs[b][c];
            }
            result[a][c] = element;
        }
    }
    return result;
}
 
template <typename T1, typename T2, std::size_t A, std::size_t B,
    typename OT = decltype(T1{} * T2{})>
PLAYRHO_CONSTEXPR inline
std::enable_if_t<IsMultipliable<T1, T2>::value && !IsVector<T1>::value, Vector<OT, B>>
operator* (const Vector<T1, A>& lhs, const Vector<Vector<T2, B>, A>& rhs) noexcept
{
    auto result = Vector<OT, B>{};
    for (auto b = decltype(B){0}; b < B; ++b)
    {
        auto element = OT{};
        for (auto a = decltype(A){0}; a < A; ++a)
        {
            element += lhs[a] * rhs[a][b];
        }
        result[b] = element;
    }
    return result;
}
 
template <typename T1, typename T2, std::size_t A, std::size_t B,
    typename OT = decltype(T1{} * T2{})>
PLAYRHO_CONSTEXPR inline
std::enable_if_t<IsMultipliable<T1, T2>::value && !IsVector<T2>::value, Vector<OT, B>>
operator* (const Vector<Vector<T1, A>, B>& lhs, const Vector<T2, A>& rhs) noexcept
{
    auto result = Vector<OT, B>{};
    for (auto b = decltype(B){0}; b < B; ++b)
    {
        auto element = OT{};
        for (auto a = decltype(A){0}; a < A; ++a)
        {
            element += lhs[b][a] * rhs[a];
        }
        result[b] = element;
    }
    return result;
}
 
template <std::size_t N, typename T1, typename T2, typename OT = decltype(T1{} * T2{})>
PLAYRHO_CONSTEXPR inline
std::enable_if_t<IsMultipliable<T1, T2>::value && !IsVector<T1>::value, Vector<OT, N>>
operator* (const T1 s, Vector<T2, N> a) noexcept
{
    // Can't base this off of *= since result type in this case can be different
    auto result = Vector<OT, N>{};
    for (auto i = decltype(N){0}; i < N; ++i)
    {
        result[i] = s * a[i];
    }
    return result;
}
 
template <std::size_t N, typename T1, typename T2, typename OT = decltype(T1{} * T2{})>
PLAYRHO_CONSTEXPR inline
std::enable_if_t<IsMultipliable<T1, T2>::value && !IsVector<T2>::value, Vector<OT, N>>
operator* (Vector<T1, N> a, const T2 s) noexcept
{
    // Can't base this off of *= since result type in this case can be different
    auto result = Vector<OT, N>{};
    for (auto i = decltype(N){0}; i < N; ++i)
    {
        result[i] = a[i] * s;
    }
    return result;
}
 
template <std::size_t N, typename T1, typename T2, typename OT = decltype(T1{} / T2{})>
PLAYRHO_CONSTEXPR inline
std::enable_if_t<IsDivisable<T1, T2>::value && !IsVector<T2>::value, Vector<OT, N>>
operator/ (Vector<T1, N> a, const T2 s) noexcept
{
    // Can't base this off of /= since result type in this case can be different
    auto result = Vector<OT, N>{};
    const auto inverseS = Real{1} / s;
    for (auto i = decltype(N){0}; i < N; ++i)
    {
        result[i] = a[i] * inverseS;
    }
    return result;
}
 
template <std::size_t I, std::size_t N, typename T>
PLAYRHO_CONSTEXPR inline auto& get(Vector<T, N>& v) noexcept
{
    static_assert(I < N, "Index out of bounds in playrho::get<> (playrho::Vector)");
    return v[I];
}
 
template <std::size_t I, std::size_t N, typename T>
PLAYRHO_CONSTEXPR inline auto get(const Vector<T, N>& v) noexcept
{
    static_assert(I < N, "Index out of bounds in playrho::get<> (playrho::Vector)");
    return v[I];
}
 
template <typename T, std::size_t N>
::std::ostream& operator<< (::std::ostream& os, const Vector<T, N>& value)
{
    os << "{";
    for (auto i = decltype(N){0}; i < N; ++i)
    {
        if (i > decltype(N){0})
        {
            os << ',';
        }
        os << value[i];
    }
    os << "}";
    return os;
}
 
} // namespace playrho
 
namespace std {
    
    template<class T, std::size_t N>
    class tuple_size< playrho::Vector<T, N> >: public std::integral_constant<std::size_t, N> {};
    
    template<std::size_t I, class T, std::size_t N>
    class tuple_element<I, playrho::Vector<T, N>>
    {
    public:
        using type = T;
    };
    
} // namespace std
 
#endif // PLAYRHO_COMMON_VECTOR_HPP