Vector.hpp

Go to the documentation of this file.

//          Copyright Dominic Koepke 2021 - 2022.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          https://www.boost.org/LICENSE_1_0.txt)
 
#ifndef SIMPLE_VECTOR_VECTOR_HPP
#define SIMPLE_VECTOR_VECTOR_HPP
 
#pragma once
 
#include "Algorithm.hpp"
#include "Concepts.hpp"
#include "Functional.hpp"
 
#include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <concepts>
#include <execution>
#include <ranges>
 
namespace sl::vec
{
    template <value_type T, std::size_t VDimensions>
        requires (0 < VDimensions)
    class Vector
    {
    public:
        constexpr static std::size_t dimensions{ VDimensions };
        using value_type = std::remove_cvref_t<T>;
        using storage_type = std::array<value_type, dimensions>;
 
        constexpr Vector() noexcept = default;
        constexpr ~Vector() noexcept = default;
        constexpr Vector(const Vector&) noexcept = default;
        constexpr Vector(Vector&&) noexcept = default;
 
        template <class... TArgs>
            requires (sizeof...(TArgs) == dimensions && (std::convertible_to<TArgs, T> && ...))
        explicit (VDimensions <= 1)
        constexpr Vector(TArgs&&...args) noexcept
            : m_Values{ static_cast<T>(args)... }
        {
        }
 
        template <std::convertible_to<value_type> T2, auto VOtherDimensions>
            requires (!std::same_as<T2, value_type> || dimensions != VOtherDimensions)
        constexpr explicit Vector(const Vector<T2, VOtherDimensions>& other)
        {
            transform_unseq
            (
                std::ranges::take_view{ other, std::min(dimensions, VOtherDimensions) },
                std::ranges::begin(m_Values),
                fn::cast_invoke_result<value_type>(std::identity{})
            );
        }
 
        template <std::invocable TGenerator>
            requires std::convertible_to<std::invoke_result_t<TGenerator&>, value_type>
        constexpr explicit Vector(TGenerator generator)
        {
            std::ranges::generate(m_Values, std::ref(generator));
        }
 
        constexpr Vector& operator =(const Vector&) noexcept = default;
        constexpr Vector& operator =(Vector&&) noexcept = default;
 
        [[nodiscard]]
        constexpr bool operator ==(const Vector&) const noexcept = default;
 
        [[nodiscard]]
        constexpr const value_type& operator [](std::integral auto index) const noexcept
        {
            assert(std::in_range<std::size_t>(index) && "index must be in range of type std::size_t");
            return m_Values[static_cast<std::size_t>(index)];
        }
 
        template <std::integral TIndex>
        [[nodiscard]]
        constexpr value_type& operator [](std::integral auto index) noexcept
        {
            assert(std::in_range<std::size_t>(index) && "index must be in range of type std::size_t");
            return m_Values[static_cast<std::size_t>(index)];
        }
 
        [[nodiscard]]
        constexpr const value_type& x() const noexcept
        {
            return m_Values[0];
        }
 
        [[nodiscard]]
        constexpr value_type& x() noexcept
        {
            return m_Values[0];
        }
 
        [[nodiscard]]
        constexpr const value_type& y() const noexcept
            requires (1 < VDimensions)
        {
            return m_Values[1];
        }
 
        [[nodiscard]]
        constexpr value_type& y() noexcept
            requires (1 < VDimensions)
        {
            return m_Values[1];
        }
 
        [[nodiscard]]
        constexpr const value_type& z() const noexcept
            requires (2 < VDimensions)
        {
            return m_Values[2];
        }
 
        [[nodiscard]]
        constexpr value_type& z() noexcept
            requires (2 < VDimensions)
        {
            return m_Values[2];
        }
 
        template <std::convertible_to<value_type> T2>
        constexpr Vector& operator +=(const Vector<T2, dimensions>& other)
        {
            transform_unseq
            (
                m_Values,
                other,
                std::ranges::begin(m_Values),
                fn::cast_invoke_result<value_type>(std::plus{})
            );
            return *this;
        }
 
        template <std::convertible_to<value_type> T2>
        constexpr Vector& operator -=(const Vector<T2, dimensions>& other)
        {
            transform_unseq
            (
                m_Values,
                other,
                std::ranges::begin(m_Values),
                fn::cast_invoke_result<value_type>(std::minus{})
            );
            return *this;
        }
 
        template <std::convertible_to<value_type> T2>
        constexpr Vector& operator +=(const T2& value)
        {
            transform_unseq
            (
                m_Values,
                std::ranges::begin(m_Values),
                fn::cast_invoke_result<value_type>([&value](const auto& lhs) { return lhs + value; })
            );
            return *this;
        }
 
        template <std::convertible_to<value_type> T2>
        constexpr Vector& operator -=(const T2& value)
        {
            transform_unseq
            (
                m_Values,
                std::ranges::begin(m_Values),
                fn::cast_invoke_result<value_type>([&value](const auto& lhs) { return lhs - value; })
            );
            return *this;
        }
 
        template <std::convertible_to<value_type> T2>
        constexpr Vector& operator *=(const T2& value)
        {
            transform_unseq
            (
                m_Values,
                std::ranges::begin(m_Values),
                fn::cast_invoke_result<value_type>([&value](const auto& lhs) { return lhs * value; })
            );
            return *this;
        }
 
        template <std::convertible_to<value_type> T2>
        constexpr Vector& operator /=(const T2& value)
        {
            assert(value != 0 && "division by 0 is undefined.");
 
            transform_unseq
            (
                m_Values,
                std::ranges::begin(m_Values),
                fn::cast_invoke_result<value_type>([&value](const auto& lhs) { return lhs / value; })
            );
            return *this;
        }
 
        template <std::convertible_to<value_type> T2>
            requires modable<T>
        constexpr Vector& operator %=(const T2& rawValue)
        {
            const auto value = static_cast<value_type>(rawValue);
            assert(value != 0 && "division by 0 is undefined.");
 
            transform_unseq
            (
                m_Values,
                std::ranges::begin(m_Values),
                [value](const auto& lhs) { return lhs % value; }
            );
            return *this;
        }
 
        [[nodiscard]]
        constexpr auto begin() noexcept { return std::ranges::begin(m_Values); }
 
        [[nodiscard]]
        constexpr auto begin() const noexcept { return std::ranges::begin(m_Values); }
 
        [[nodiscard]]
        constexpr auto cbegin() const noexcept { return std::ranges::cbegin(m_Values); }
 
        [[nodiscard]]
        constexpr auto end() noexcept { return std::ranges::end(m_Values); }
 
        [[nodiscard]]
        constexpr auto end() const noexcept { return std::ranges::end(m_Values); }
 
        [[nodiscard]]
        constexpr auto cend() const noexcept { return std::ranges::cend(m_Values); }
 
        [[nodiscard]]
        constexpr auto rbegin() noexcept { return std::ranges::rbegin(m_Values); }
 
        [[nodiscard]]
        constexpr auto rbegin() const noexcept { return std::ranges::rbegin(m_Values); }
 
        [[nodiscard]]
        constexpr auto crbegin() const noexcept { return std::ranges::crbegin(m_Values); }
 
        [[nodiscard]]
        constexpr auto rend() noexcept { return std::ranges::rend(m_Values); }
 
        [[nodiscard]]
        constexpr auto rend() const noexcept { return std::ranges::rend(m_Values); }
 
        [[nodiscard]]
        constexpr auto crend() const noexcept { return std::ranges::crend(m_Values); }
 
    private:
        storage_type m_Values{};
    };
 
    template <class... T>
    Vector(T&&...) -> Vector<std::common_type_t<T...>, sizeof...(T)>;
 
    template <value_type T, std::size_t VDimensions>
    struct vector_traits<Vector<T, VDimensions>>
    {
        using value_type = typename Vector<T, VDimensions>::value_type;
 
        static constexpr std::size_t dimensions = Vector<T, VDimensions>::dimensions;
    };
 
    template <value_type T, auto VDimensions>
    struct is_vectorial<Vector<T, VDimensions>> : std::true_type
    {
    };
 
    template <vectorial TVector, add_assignable<TVector> T2>
    [[nodiscard]]
    constexpr TVector operator +(TVector lhs, T2&& rhs)
    {
        lhs += std::forward<T2>(rhs);
        return lhs;
    }
 
    template <vectorial TVector, sub_assignable<TVector> T2>
    [[nodiscard]]
    constexpr TVector operator -(TVector lhs, T2&& rhs)
    {
        lhs -= std::forward<T2>(rhs);
        return lhs;
    }
 
    template <vectorial TVector, mul_assignable<TVector> T2>
    [[nodiscard]]
    constexpr TVector operator *(TVector lhs, T2&& rhs)
    {
        lhs *= std::forward<T2>(rhs);
        return lhs;
    }
 
    template <vectorial TVector, mul_assignable<TVector> T2>
    [[nodiscard]]
    constexpr TVector operator *(T2&& lhs, TVector rhs)
    {
        rhs *= std::forward<T2>(lhs);
        return rhs;
    }
 
    template <vectorial TVector, div_assignable<TVector> T2>
    [[nodiscard]]
    constexpr TVector operator /(TVector lhs, T2&& rhs)
    {
        lhs /= std::forward<T2>(rhs);
        return lhs;
    }
 
    template <vectorial TVector, mod_assignable<TVector> T2>
    [[nodiscard]]
    constexpr TVector operator %(TVector lhs, T2&& rhs)
    {
        lhs %= std::forward<T2>(rhs);
        return lhs;
    }
 
    template <vectorial TVector1, vectorial TVector2>
        requires mulable<vector_value_t<TVector2>, vector_value_t<TVector1>>
    [[nodiscard]]
    constexpr vector_value_t<TVector1> dot_product(const TVector1& lhs, const TVector2& rhs)
    {
        using T = vector_value_t<TVector1>;
        return transform_reduce_unseq
        (
            lhs,
            rhs,
            T{},
            std::plus{},
            fn::cast_invoke_result<T>(std::multiplies{})
        );
    }
 
    template <vectorial TVector>
    [[nodiscard]]
    constexpr vector_value_t<TVector> length_squared(const TVector& vector)
    {
        return dot_product(vector, vector);
    }
 
    template <vectorial TVector>
    [[nodiscard]]
    constexpr auto length(const TVector& vector) { return std::sqrt(length_squared(vector)); }
 
    template <vectorial TVector>
        requires std::floating_point<vector_value_t<TVector>>
    [[nodiscard]]
    constexpr TVector normalized(TVector vec)
    {
        assert(vec != TVector{});
 
        return vec /= length(vec);
    }
 
    template <vectorial TVector>
    [[nodiscard]]
    constexpr TVector projected(const TVector& vector, TVector target)
    {
        assert(vector != TVector{} && "vector must not be the null vector.");
        assert(target != TVector{} && "target must not be the null vector.");
 
        const auto dot = dot_product(vector, target);
        const auto targetLengthSq = length_squared(target);
        target *= (dot / targetLengthSq);
        return target;
    }
 
    template <vectorial TVector, class T>
        requires std::is_arithmetic_v<T>
    [[nodiscard]]
    constexpr TVector lerp(TVector vector1, const TVector& vector2, T t)
    {
        transform_unseq
        (
            vector1,
            vector2,
            std::ranges::begin(vector1),
            fn::cast_invoke_result<vector_value_t<TVector>>([t](auto a, auto b) { return std::lerp(a, b, t); })
        );
        return vector1;
    }
 
    template <vectorial TVector>
        requires std::floating_point<vector_value_t<TVector>>
    [[nodiscard]]
    constexpr TVector inversed(TVector vector)
    {
        transform_unseq
        (
            vector,
            std::ranges::begin(vector),
            [](auto value) { return 1. / value; }
        );
        return vector;
    }
 
}
 
#endif