AngleFunctions.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Base
File: AngleFunctions
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/Angle.h>
#include <NDEVR/Vector.h>
namespace NDEVR
{
    extern NDEVR_BASE_API const fltp08* const s_index_sin;
    /**\brief Greater-than comparison operator.
    \param[in] angle_a The first instance to compare.
    \param[in] angle_b The second instance to compare.
    \return True if the first parameter is greater than to the second.**/
    template<class t_type_a, class t_type_b>
    constexpr static bool operator>(const Angle<t_type_a>& angle_a, const Angle<t_type_b>& angle_b)
    {
        return angle_a.template internal<false>() > cast<t_type_a>(angle_b.template internal<false>());
    }
    /**\brief Less-than comparison operator.
    \param[in] angle_a The first instance to compare.
    \param[in] angle_b The second instance to compare.
    \return True if the first parameter is less than to the second.**/
    template<class t_type_a, class t_type_b>
    constexpr static bool operator<(const Angle<t_type_a>& angle_a, const Angle<t_type_b>& angle_b)
    {
        return angle_a.template internal<false>() < cast<t_type_a>(angle_b.template internal<false>());
    }
    /** \brief Greater-than-or-equal comparison operator.
    \param[in] angle_a The first instance to compare.
    \param[in] angle_b The second instance to compare.
    \return True if the first parameter is greater than or equal to the second.**/
    template<class t_type_a, class t_type_b>
    constexpr static bool operator>=(const Angle<t_type_a>& angle_a, const Angle<t_type_b>& angle_b)
    {
        return angle_a.template internal<false>() >= cast<t_type_a>(angle_b.template internal<false>());
    }
    /**\brief Less-than-or-equal comparison operator.
    \param[in] angle_a The first instance to compare.
    \param[in] angle_b The second instance to compare.
    \return True if the first parameter is less than or equal to the second.**/
    template<class t_type_a, class t_type_b>
    constexpr static bool operator<=(const Angle<t_type_a>& angle_a, const Angle<t_type_b>& angle_b)
    {
        return angle_a.template internal<false>() <= cast<t_type_a>(angle_b.template internal<false>());
    }
    /** \brief Performs optimized sine operation on the given angle using pre-computed lookup table for optimal speed.
    \param[in] angle The angle to perform sin on.
    \return The sine of the given angle**/
    template<class t_type>
    typename std::enable_if<!ObjectInfo<t_type>::Float, fltp08>::type sin(const Angle<t_type>& angle)
    {
 
        const uint02 internal_angle = cast<uint02>(angle.template internal<true>());
        if (internal_angle <= Angle<t_type>::INDEX_PI)
        {
            if (internal_angle > (Angle<t_type>::INDEX_PI / 2))
                return s_index_sin[Angle<t_type>::INDEX_PI - internal_angle];
            else
                return s_index_sin[internal_angle];
        }
        else
        {
            if (internal_angle >= Angle<t_type>::INDEX_PI + (Angle<t_type>::INDEX_PI / 2))
                return -s_index_sin[2 * Angle<t_type>::INDEX_PI - internal_angle];
            else
                return -s_index_sin[internal_angle - Angle<t_type>::INDEX_PI];
        }
    }
    /**
    \brief Performs sine operation on the given angle.
    \param[in] angle The angle to perform sin on.
    \return The sine of the given angle
     **/
    template<class t_type>
    typename std::enable_if<ObjectInfo<t_type>::Float, fltp08>::type sin(const Angle<t_type>& angle)
    {
        return ::sin(angle.template as<RADIANS>());
    }
    /**
    \brief Performs sine operation on the given number assumed to be in radians.
    \param[in] angle The number, in radians to perform sin on.
    \return The sine of the given angle
     **/
    template<class t_type>
    t_type sin(const t_type& angle)
    {
        return ::sin(angle);
    }
    /**
    \brief Performs optimized cosine operation on the given angle using pre-computed lookup table for optimal speed.
    \param[in] angle The angle to perform cosin on.
    \return The cosine of the given angle
     **/
    template<class t_type>
    typename std::enable_if<!ObjectInfo<t_type>::Float, fltp08>::type cos(const Angle<t_type>& angle)
    {
        const Angle<t_type> internal_angle = Angle<t_type>(cast<uint02>((angle.template internal<true>() + (Angle<t_type>::INDEX_PI / 2)) % (2 * Angle<t_type>::INDEX_PI)));
        return sin(internal_angle);
    }
    /**
    \brief Performs cosine operation on the given angle.
    \param[in] angle The angle to perform cosine on.
    \return The cosine of the given angle
     **/
    template<class t_type>
    typename std::enable_if<ObjectInfo<t_type>::Float, fltp08>::type cos(const Angle<t_type>& angle)
    {
        return ::cos(angle.template as<RADIANS>());
    }
    /**
    \brief Performs cosine operation on the given angle assumed to be in radians.
    \param[in] angle The number, in radians, to perform cosine on.
    \return The cosine of the given angle
     **/
    template<class t_type>
    t_type cos(const t_type& angle)
    {
        return ::cos(angle);
    }
 
    /**
    \brief Performs optimized tangent operation on the given angle using pre-computed lookup table for optimal speed.
    \param[in] angle The angle to perform tangent on.
    \return The tangent of the given angle
     **/
    template<class t_type>
    typename std::enable_if<!ObjectInfo<t_type>::Float, fltp08>::type tan(const Angle<t_type>& angle)
    {
        return sin(angle) / cos(angle);
    }
    /**
    \brief Performs tan operation on the given angle.
    \param[in] angle The angle to perform tan on.
    \return The tangent of the given angle
     **/
    template<class t_type>
    typename std::enable_if<ObjectInfo<t_type>::Float, fltp08>::type tan(const Angle<t_type>& angle)
    {
        return ::tan(angle.template as<RADIANS>());
    }
 
    /**
    \brief Performs tan operation on the given angle assumed to be in radians.
    \param[in] angle The angle, in radians, to perform tan on.
    \return The tangent of the given angle
     **/
    template<class t_type>
    t_type tan(const t_type& angle)
    {
        return ::tan(angle);
    }
 
    /**
    \brief Subtraction operator.
    \param[in] angle_a The first value.
    \param[in] angle_b A value to subtract from it.
    \return The result of the subtraction operation.
     **/
    template<class t_type>
    constexpr static Angle<t_type> operator-(const Angle<t_type>& angle_a, const Angle<t_type>& angle_b)
    {
        return Angle<t_type>(cast<t_type>(angle_a.template internal<false>() - angle_b.template internal<false>()));
    }
    /**
    \brief Addition operator.
    \param[in] angle_a The first value.
    \param[in] angle_b A value to add to it.
    \return The result of the addition operation.
    **/
    template<class t_type>
    constexpr static Angle<t_type> operator+(const Angle<t_type>& angle_a, const Angle<t_type>& angle_b)
    {
        return Angle<t_type>(cast<t_type>(angle_a.template internal<false>() + angle_b.template internal<false>()));
    }
 
    /**
    \brief Calculates minimal absolute signed angle between two angles
    \param[in] angle_a The first angle.
    \param[in] angle_b The second angle
    \return The absolute minimal angle (-180 to 180 degrees) between the two angles
    **/
    template<class t_type>
    constexpr static Angle<t_type> difference(const Angle<t_type>& angle_a, const Angle<t_type>& angle_b)
    {
        Angle<t_type> angle = (angle_a - angle_b).normalized();
        if (angle <= Angle<t_type>(DEGREES, 180.0f))
            return angle;
        else
            return Angle<t_type>(DEGREES, -360.0f) + angle;
    }
    /**
    \brief Calculates the minimal absolute signed angle between two angles
    \param[in] angle_a A vector of the first angle.
    \param[in] angle_b A vector of the second angle
    \return The A vector that for each axis returns the absolute minimal angle (-180 to 180 degrees) 
        between the two input angles
    **/
    template<uint01 t_dims, class t_type>
    constexpr static Vector<t_dims, Angle<t_type>> difference(const Vector<t_dims, Angle<t_type>>& angle_a, const Vector<t_dims, Angle<t_type>>& angle_b)
    {
        Vector<t_dims, Angle<t_type>> angle;
        for (uint01 dim = 0; dim < t_dims; ++dim)
        {
            angle[dim] = difference(angle_a[dim], angle_b[dim]);
        }
        return angle;
    }
 
    /**
    \brief Calculates the average of two normalized angles. For example 359.1 and 720.1 would average to
        be 0.0 and 0.0 and 180.0 would average to be 90.0
    \param[in] angle_a the first angle.
    \param[in] angle_b the second angle
    \return The averaged normalized angle
    **/
    template<class t_type>
    constexpr static Angle<t_type> Average(const Angle<t_type>& angle_a, const Angle<t_type>& angle_b)
    {
        Angle<t_type> angle = difference(angle_a, angle_b) / 2.0;
        angle += angle_b;
        return angle;
    }
 
    /**
    \brief Calculates the average of two normalized angles. For example 359.1 and 720.1 would average to
        be 0.0 and 0.0 and 180.0 would average to be 90.0
    \param[in] angle_a the first angle.
    \param[in] angle_b the second angle
    \return The averaged normalized angle
    **/
    template<uint01 t_dims, class t_type>
    constexpr static Vector<t_dims, Angle<t_type>> Average(const Vector<t_dims, Angle<t_type>>& angle_a, const Vector<t_dims, Angle<t_type>>& angle_b)
    {
        Vector<t_dims, Angle<t_type>> angle;
        for (uint01 dim = 0; dim < t_dims; ++dim)
        {
            angle[dim] = Average(angle_a[dim], angle_b[dim]);
        }
        return angle;
    }
    
    /**
    \brief Multiplication operator.
    \param[in] angle_a The first value.
    \param[in] angle_b A value to add to it.
    \return The result of the multiplication operation.
    **/
    template<class t_type>
    constexpr static Angle<t_type> operator*(const Angle<t_type>& angle_a, const Angle<t_type>& angle_b)
    {
        return Angle<t_type>(cast<t_type>(angle_a.template internal<false>() * angle_b.template internal<false>()));
    }
 
    /**
    \brief Division operator.
    \param[in] angle_a The first value.
    \param[in] angle_b A value to add to it.
    \return The result of the division operation.
    **/
    template<class t_type>
    constexpr static fltp08 operator/(const Angle<t_type>& angle_a, const Angle<t_type>& angle_b)
    {
        return cast<fltp08>(angle_a.template internal<false>()) / cast<fltp08>(angle_b.template internal<false>());
    }
 
    /**
    \brief Multiplication operator.
    \param[in] angle An angle to multiply
    \param[in] mult A scaler value to multiply the angle by.
    \return The result of the multiplication operation.
    **/
    template<class t_type, class t_angle_type>
    constexpr static Angle<t_angle_type> operator*(const Angle<t_angle_type>& angle, t_type mult)
    {
        return Angle<t_angle_type>(cast<t_angle_type>(cast<t_type>(angle.template internal<false>()) * mult));
    }
 
    /**
    \brief Multiplication operator.
    \param[in] mult A scaler value to multiply the angle by.
    \param[in] angle The angle to multiply.
    \return The result of the multiplication operation.
    **/
    template<class t_type, class t_angle_type>
    constexpr static Angle<t_angle_type> operator*(t_type mult, const Angle<t_angle_type>& angle)
    {
        return Angle<t_angle_type>(cast<t_angle_type>(cast<t_type>(angle.template internal<false>()) * mult));
    }
    /**
    \brief Multiplication operator for a Vector of Angles.
    \param[in] mult A scaler value to multiply the angle by.
    \param[in] angle The vector of Angles to multiply.
    \return The result of the multiplication operation.
    **/
    template<class t_type, class t_vector_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, Angle<fltp08>>::value, t_vector_type>::type
    operator*(const t_vector_type& angle, const t_type& mult)
    {
        t_vector_type product;
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); ++dim)
            product[dim] = angle[dim] * mult;
        return product;
    }
 
    /**
    \brief Multiplication operator for a Vector of Angles.
    \param[in] mult A scaler value to multiply the angle by.
    \param[in] angle The vector of Angles to multiply.
    \return The result of the multiplication operation.
    **/
    template<class t_type, class t_vector_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, Angle<sint04>>::value, t_vector_type>::type
    operator*(const t_vector_type& angle, const t_type& mult)
    {
        t_vector_type product;
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); ++dim)
            product[dim] = angle[dim] * mult;
        return product;
    }
 
    /**
    \brief Multiplication operator for a Vector of Angles.
    \param[in] mult A Vector scaler value to multiply the angle by.
    \param[in] angle The vector of Angles to multiply.
    \return The result of the multiplication operation.
    **/
    template<uint01 t_dims, class t_type, class t_vector_type>
    constexpr typename std::enable_if<std::is_base_of<Vector<t_dims, Angle<fltp08>>, t_vector_type>::value, t_vector_type>::type
    operator*(const t_vector_type& angle, const Vector<t_dims, t_type>& mult)
    {
        t_vector_type product;
        for (uint01 dim = 0; dim < t_dims; ++dim)
            product[dim] = angle[dim] * mult[dim];
        return product;
    }
 
    /**
    \brief Multiplication operator for a Vector of Angles.
    \param[in] angle The vector of Angles to multiply.
    \param[in] mult A Vector scaler value to multiply the angle by.
    \return The result of the multiplication operation.
    **/
    template<uint01 t_dims, class t_type, class t_vector_type>
    constexpr typename std::enable_if<std::is_base_of<Vector<t_dims, Angle<sint04>>, t_vector_type>::value, t_vector_type>::type
    operator*(const t_vector_type& angle, const Vector<t_dims, t_type>& mult)
    {
        t_vector_type product;
        for (uint01 dim = 0; dim < t_dims; ++dim)
            product[dim] = angle[dim] * mult[dim];
        return product;
    }
 
    template<class t_type, class t_vector_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, Angle<fltp08>>::value, t_vector_type>::type
    operator*(const t_type& mult, const t_vector_type& angle)
    {
        t_vector_type product;
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); ++dim)
            product[dim] = mult * angle[dim];
        return product;
    }
    template<class t_type, class t_vector_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, Angle<sint04>>::value, t_vector_type>::type
    operator*(const t_type& mult, const t_vector_type& angle)
    {
        t_vector_type product;
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); ++dim)
            product[dim] = mult * angle[dim];
        return product;
    }
    template<uint01 t_dims, class t_type, class t_vector_type>
    constexpr typename std::enable_if<std::is_base_of<Vector<t_dims, Angle<fltp08>>, t_vector_type>::value, t_vector_type>::type
    operator*(const Vector<t_dims, t_type>& mult, const t_vector_type& angle)
    {
        t_vector_type product;
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); ++dim)
            product[dim] = mult[dim] * angle[dim];
        return product;
    }
    template<uint01 t_dims, class t_type, class t_vector_type>
    constexpr typename std::enable_if<std::is_base_of<Vector<t_dims, Angle<sint04>>, t_vector_type>::value, t_vector_type>::type
    operator*(const Vector<t_dims, t_type>& mult, const t_vector_type& angle)
    {
        t_vector_type product;
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); ++dim)
            product[dim] = mult[dim] * angle[dim];
        return product;
    }
    template<class t_type, class t_vector_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, Angle<fltp08>>::value, t_vector_type>::type
    operator*(const t_vector_type& mult, const t_vector_type& angle)
    {
        t_vector_type product;
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); ++dim)
            product[dim] = mult[dim] * angle[dim];
        return product;
    }
    template<class t_type, class t_vector_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, Angle<sint04>>::value, t_vector_type>::type
    operator*(const t_vector_type& mult, const t_vector_type& angle)
    {
        t_vector_type product;
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); ++dim)
            product[dim] = mult[dim] * angle[dim];
        return product;
    }
    /**
    \brief Division operator for a Vector of Angles.
    \param[in] angle The Angles to divide.
    \param[in] den A scaler value to divide the angle by.
    \return The result of the multiplication operation.
    **/
    template<class t_type, class t_angle_type>
    constexpr static Angle<t_angle_type> operator/(const Angle<t_angle_type>& num, t_type den)
    {
        return Angle<t_angle_type>(cast<t_angle_type>(cast<t_type>(num.template internal<false>()) / den));
    }
 
    /**
    \brief Division operator for a Vector of Angles.
    \param[in] den A scaler value to divide the angle by.
    \param[in] angle The Vector of Angles to divide.
    \return The result of the multiplication operation.
    **/
    template<class t_type, class t_vector_type, class t_angle_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, Angle<t_angle_type>>::value, t_vector_type>::type
    operator/(const t_vector_type& angle, const t_type& den)
    {
        t_vector_type div;
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); ++dim)
            div[dim] = angle[dim] / den;
        return div;
    }
 
    /**
    \brief Division operator for a Vector of Angles.
    \param[in] den A scaler value to divide the angle by.
    \param[in] angle The Vector of Angles to divide.
    \return The result of the multiplication operation.
    **/
    template<class t_type, class t_vector_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, Angle<fltp08>>::value, t_vector_type>::type
    operator/(const t_vector_type& angle, const t_type& den)
    {
        t_vector_type div;
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); ++dim)
            div[dim] = angle[dim] / den;
        return div;
    }
 
    /**
    \brief Division operator for a Vector of Angles.
    \param[in] den A scaler value to divide the angle by.
    \param[in] angle The Vector of Angles to divide.
    \return The result of the multiplication operation.
    **/
    template<class t_type, class t_vector_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, Angle<sint04>>::value, t_vector_type>::type
    operator/(const t_vector_type& angle, const t_type& den)
    {
        t_vector_type div;
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); ++dim)
            div[dim] = angle[dim] / den;
        return div;
    }
 
    /**
    \brief Division operator for a Vector of Angles.
    \param[in] den A scaler value the angle will divide by.
    \param[in] angle The Vector of Angles to divide the den by.
    \return The result of the multiplication operation.
    **/
    template<uint01 t_dims, class t_type, class t_vector_type, class t_angle_type>
    constexpr typename std::enable_if<std::is_base_of<Vector<t_dims, Angle<t_angle_type>>, t_vector_type>::value, t_vector_type>::type
    operator/(const t_vector_type& angle, const Vector<t_dims, t_type>& den)
    {
        t_vector_type div;
        for (uint01 dim = 0; dim < t_dims; ++dim)
            div[dim] = angle[dim] / den[dim];
        return div;
    }
 
    /**
    \brief Division operator for a Vector of Angles.
    \param[in] den A scaler value the angle will divide by.
    \param[in] angle The Vector of Angles to divide the den by.
    \return The result of the multiplication operation.
    **/
    template<uint01 t_dims, class t_vector_type, class t_angle_type>
    constexpr typename std::enable_if<std::is_base_of<Vector<t_dims, Angle<t_angle_type>>, t_vector_type>::value, Vector<t_dims, fltp08>>::type
    operator/(const t_vector_type& angle, const Vector<t_dims, Angle<t_angle_type>>& den)
    {
        Vector<t_dims, fltp08> div;
        for (uint01 dim = 0; dim < t_dims; ++dim)
            div[dim] = angle[dim] / den[dim];
        return div;
    }
    /**
    \brief Division operator for a Vector of Angles.
    \param[in] den A scaler value the angle will divide by.
    \param[in] angle The Vector of Angles to divide the den by.
    \return The result of the multiplication operation.
    **/
    template<uint01 t_dims, class t_angle_type>
    constexpr Vector<t_dims, fltp08> operator/(const Vector<t_dims, Angle<t_angle_type>>& angle, const Vector<t_dims, Angle<t_angle_type>>& den)
    {
        Vector<t_dims, fltp08> div;
        for (uint01 dim = 0; dim < t_dims; ++dim)
            div[dim] = angle[dim] / den[dim];
        return div;
    }
    
    template<class t_type, class t_angle_type>
    constexpr static Angle<t_angle_type> operator/(t_type num, const Angle<t_angle_type>& den)
    {
        return Angle(cast<t_angle_type>(num / cast<t_type>(den.template internal<false>())));
    }
    template<class t_type, class t_vector_type, class t_angle_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, Angle<t_angle_type>>::value, t_vector_type>::type
    operator/(t_type num, const t_vector_type& angle)
    {
        t_vector_type div;
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); ++dim)
            div[dim] = num / angle[dim];
        return div;
    }
    template<class t_angle_type>
    constexpr static Angle<t_angle_type>& operator+=(Angle<t_angle_type>& angle, const Angle<t_angle_type>& add)
    {
        angle = angle + add;
        return angle;
    }
    template<class t_angle_type>
    constexpr static Angle<t_angle_type>& operator-=(Angle<t_angle_type>& angle, const Angle<t_angle_type>& sub)
    {
        angle = angle - sub;
        return angle;
    }
    template<class t_type, class t_angle_type>
    constexpr static Angle<t_angle_type>& operator*=(Angle<t_angle_type>& angle, const t_type& mult)
    {
        angle = angle * mult;
        return angle;
    }
    template<uint01 t_dims, class t_type, class t_angle_type>
    constexpr static Vector<t_dims, Angle<t_angle_type>>& operator*=(Vector<t_dims, Angle<t_angle_type>>& angle, const t_type& mult)
    {
        for (uint01 dim = 0; dim < t_dims; ++dim)
            angle[dim] = angle[dim] * mult;
        return angle;
    }
    template<uint01 t_dims, class t_type, class t_angle_type>
    constexpr static Vector<t_dims, Angle<t_angle_type>>& operator*=(Vector<t_dims, Angle<t_angle_type>>& angle, const Vector<t_dims, t_type>& mult)
    {
        for (uint01 dim = 0; dim < t_dims; ++dim)
            angle[dim] = angle[dim] * mult[dim];
        return angle;
    }
    template<class t_angle_type>
    constexpr static Angle<t_angle_type>& operator*=(Angle<t_angle_type>& angle, const Angle<t_angle_type>& mult)
    {
        angle = angle * mult;
        return angle;
    }
 
    template<class t_type, class t_angle_type>
    constexpr static Angle<t_angle_type>& operator/=(Angle<t_angle_type>& angle, const t_type& mult)
    {
        angle = angle / mult;
        return angle;
    }
    template<uint01 t_dims, class t_type, class t_angle_type>
    constexpr static Vector<t_dims, Angle<t_angle_type>>& operator/=(Vector<t_dims, Angle<t_angle_type>>& angle, const t_type& den)
    {
        for (uint01 dim = 0; dim < t_dims; ++dim)
            angle[dim] = angle[dim] / den;
        return angle;
    }
    template<uint01 t_dims, class t_type, class t_angle_type>
    constexpr static Vector<t_dims, Angle<t_angle_type>>& operator/=(Vector<t_dims, Angle<t_angle_type>>& angle, const Vector<t_dims, t_type>& den)
    {
        for (uint01 dim = 0; dim < t_dims; ++dim)
            angle[dim] = angle[dim] / den[dim];
        return angle;
    }
 
    template<uint01 t_dims, class t_angle_type>
    constexpr Vector<t_dims, Angle<t_angle_type>> operator%(const Vector<t_dims, Angle<t_angle_type>>& vec_a, const Vector<t_dims, Angle<t_angle_type>>& vec_b)
    {
        Vector<t_dims, Angle<t_angle_type>> mod;
        for (uint01 dim = 0; dim < t_dims; ++dim)
            mod[dim] = Angle<t_angle_type>(cast<t_angle_type>(vec_a[dim].template internal<false>() % vec_b[dim].template internal<false>()));
        return mod;
    }
    /**
    \brief Computes the remainder of an Angle given an angle and a modulo divisor.
    \param[in] vec_a The Vector to compute the remainder.
    \param[in] value_b The Vector to use as the modulo
    \return The result of the modulo operation.
    **/
    template<uint01 t_dims, class t_angle_type>
    constexpr Vector<t_dims, Angle<t_angle_type>> operator%(const Vector<t_dims, Angle<t_angle_type>>& vec_a, const Angle<t_angle_type>& value_b)
    {
        Vector<t_dims, Angle<t_angle_type>> mod;
        for (uint01 dim = 0; dim < t_dims; ++dim)
            mod[dim] = Angle<t_angle_type>(cast<t_angle_type>(vec_a[dim].template internal<false>() % value_b.template internal<false>()));
        return mod;
    }
 
    /**
    \brief Changes an input with a negative sign, to a positive sign.
    \param[in] value The signed angle
    \return The absolute value of the input angle
    **/
    template<class t_angle_type>
    constexpr Angle<t_angle_type> abs(const Angle<t_angle_type>& value)
    {
        return value >= Angle<t_angle_type>(0) ? value : -value;
    }
 
    
    /**
    \brief Converts a Vector of one angle to a different container type
    \param[in] old The value to change into a different angle container
    \return The same angle with a new container type
    **/
    template<class t_new_type, uint01 t_dims, class t_angle_type>
    constexpr Vector<t_dims, Angle<t_new_type>> ToTypeAngle(const Vector<t_dims, Angle<t_angle_type>>& old)
    {
        Vector<t_dims, Angle<t_new_type>> angle;
        for(uint01 dim = 0; dim < t_dims; ++dim)
            angle[dim] = old[dim].template toTypeAngle<t_new_type>();
        return angle;
    }
 
    /**
    \brief Logic for converting between Euler angles and basic rotations or normals
     **/
    class NDEVR_BASE_API AngleDefinitions
    {
    public:
         /**
         \brief Converts a quaternion to Euler angles (Roll, Pitch and Yaw)
         \param[in] quaternion The quaternion to compute
         \return The Euler angles of that quaternion.
         **/
        static Vector<3, Angle<fltp08>> QuaternionToOrientation(const Vector<4, fltp08>& quaternion);
 
        /**
                
        Gets a rotation.
        
        Author: Tyler Parke
        
        Date: 2017-11-13
        
        Parameters:
        left -      The left.
        middle -    The middle.
        right -     The right.
        
        \returns The rotation.
         **/
        template<class t_angle_type, uint01 t_dims, class t_type>
        static Angle<t_angle_type> Rotation(const Vector<t_dims, t_type>& left, const Vector<t_dims, t_type>& middle, const Vector<t_dims, t_type>& right)
        {
            const Vector<t_dims, t_type> v_left(left - middle);
            const Vector<t_dims, t_type> v_right(right - middle);
            return Angle<t_angle_type>(RADIANS, acos(dot(v_left, v_right) / cast<fltp08>(sqrt(v_left.magnitudeSquared() * v_right.magnitudeSquared()))));
        }
        /**
                Gets the Inclination of .
 
        Author: Tyler Parke
 
        Date: 2018-08-15
 
        Parameters:
        roll -     The rotation about the X axis.
        pitch -    The rotation about the Y axis.
 
        \returns The rotation.
        **/
        template<class t_angle_type>
        static Angle< t_angle_type> Inclination(const Angle<t_angle_type>& roll, const Angle<t_angle_type>& pitch)
        {
            return Angle<t_angle_type>::atan(cast<fltp08>(sqrt(tan(roll) * tan(roll) + tan(pitch) * tan(pitch))));
        }
 
        template<class t_angle_type, uint01 t_dims, class t_type>
        static constexpr Angle<t_angle_type> Inclination(const Vector<t_dims, t_type> ray)
        {
            const Vector<2, t_type> xy_diff = ray.template as<2, t_type>();
            return Angle<t_angle_type>::atan2(ray[Z], xy_diff.template magnitude<t_type>());
        }
 
        template<class t_angle_type, uint01 t_dims, class t_type>
        static constexpr Angle<t_angle_type> Heading(const Vector<t_dims, t_type> ray)
        {
            return Angle<t_angle_type>::atan2(ray[Y], ray[X]);
        }
 
        template<class t_angle_type, uint01 t_dims, class t_type>
        static constexpr Vector<t_dims, Angle<t_angle_type>> Orientation(AngleType angle_type, const Vector<t_dims, t_type>& ray)
        {
            Vector<t_dims, Angle<t_angle_type>> orient_vector;
            for (uint01 i = 0; i < t_dims; i++)
                orient_vector[i] = Angle<t_angle_type>(angle_type, ray[i]);
            return orient_vector;
        }
        template<bool t_normalized, uint01 t_dims, class t_angle_type>
        static constexpr Vector<t_dims, fltp08> Orientation(AngleType angle_type, const Vector<t_dims, Angle<t_angle_type>>& ray)
        {
            Vector<t_dims, fltp08> orient_vector;
            for (uint01 i = 0; i < t_dims; i++)
                orient_vector[i] = ray[i].as(angle_type);
            return orient_vector;
        }
        /**
                
        Normal to orientation.
        
        Author: Tyler Parke
        
        Date: 2017-11-13
        
        Parameters:
        normal -    The normal.
        yaw -       (Optional) The yaw.
        
        \returns A Vector&lt;3,Angle&gt;
         **/
        template<class t_angle_type, class t_type>
        static Vector<3, Angle<t_angle_type>> NormalToOrientation(const Vector<3, t_type>& normal, const Angle<t_angle_type>& yaw = Angle<t_angle_type>(0))
        {
            Angle<t_angle_type> pitch(RADIANS, (cast<fltp08>(asin((normal[Y] * sin(yaw) + normal[X] * cos(yaw))))));
            Angle<t_angle_type> roll;
            if (::fabs(cos(pitch)) < 0.001)
                roll = Angle<t_angle_type>(DEGREES, 0.0);
            else if (::fabs(cos(yaw)) < 0.01)
                roll = Angle<t_angle_type>(RADIANS, cast<fltp08>(-asin((cos(yaw) * sin(pitch) - normal[X]) / cos(pitch) * -sin(yaw))));
            else
                roll = Angle<t_angle_type>(RADIANS, cast<fltp08>(-asin((-normal[Y] + sin(yaw) * sin(pitch)) / (cos(pitch) * cos(yaw)))));
            if (normal[Z] < 0)
                roll = Angle<t_angle_type>(DEGREES, 180.0) - roll;
            return Vector<3, Angle<t_angle_type>>(roll, pitch, yaw);
        }
 
        template<class t_angle_type>
        static Vector<3, Angle<t_angle_type>> NormalizeOrientation(Vector<3, Angle<t_angle_type>> angle, const Vector<3, Angle<t_angle_type>>& reference)
        {
            fltp08 suggested_pitch_value = angle[PITCH].template as<DEGREES>();
            fltp08 our_pitch_value = reference[PITCH].template as<DEGREES>();
 
            fltp08 suggested_yaw_value = angle[YAW].template as<DEGREES>();
            fltp08 our_yaw_value = reference[YAW].template as<DEGREES>();
 
            fltp08 suggested_roll_value = angle[ROLL].template as<DEGREES>();
            fltp08 our_roll_value = reference[ROLL].template as<DEGREES>();
 
            if (suggested_pitch_value - our_pitch_value > 180)
                our_pitch_value += 360;
            else if (our_pitch_value - suggested_pitch_value > 180)
                suggested_pitch_value += 360;
 
            if (suggested_yaw_value - our_yaw_value > 180)
                our_yaw_value += 360;
            else if (our_yaw_value - suggested_yaw_value > 180)
                suggested_yaw_value += 360;
 
            if (suggested_roll_value - our_roll_value > 180)
                our_roll_value += 360;
            else if (our_roll_value - suggested_roll_value > 180)
                suggested_roll_value += 360;
 
            bool flip = ::abs(suggested_roll_value - our_roll_value) >= 90.0f && ::abs(suggested_yaw_value - our_yaw_value) >= 90.0f;
            if (flip)
            {
                angle[ROLL] = Angle<fltp08>(DEGREES, angle[ROLL].template as<DEGREES>() - 180);
                angle[YAW] = Angle<fltp08>(DEGREES, angle[YAW].template as<DEGREES>() - 180);
            }
            return angle;
        }
 
    public:
        /**
                Calculates the index sine.
        
        Author: Tyler Parke
        
        Date: 2017-11-13
        
        \returns Null if it fails, else the calculated index sine.
         **/
        static const fltp08* CalcIndexSin();
    };
 
    template<uint01 t_dims, class t_angle_type>
    constexpr Vector<t_dims, Angle<t_angle_type>> quantize(const Vector<t_dims, Angle<t_angle_type>>& value, Angle<t_angle_type> d = Angle<t_angle_type>(DEGREES, 1.0))
    {
        return AngleDefinitions::Orientation<t_angle_type>(INTERNAL_ANGLE, quantize(AngleDefinitions::Orientation<false>(INTERNAL_ANGLE, value), d.template as<INTERNAL_ANGLE>()));
    }
 
    template<uint01 t_dims, class t_angle_type>
    constexpr Vector<t_dims, Angle<t_angle_type>> quantize(const Vector<t_dims, Angle<t_angle_type>>& value, Vector<t_dims, Angle<t_angle_type>> d = Vector<t_dims, Angle<t_angle_type>>(Angle<t_angle_type>(DEGREES, 1.0)))
    {
        return AngleDefinitions::Orientation<t_angle_type>(INTERNAL_ANGLE, quantize(AngleDefinitions::Orientation<false>(INTERNAL_ANGLE, value), AngleDefinitions::Orientation<false>(d)));
    }
};