YasiuMathDataTypes.h

Go to the documentation of this file.

/* 
 * Copyright (c) 2026 Grzegorz Krug.
 * All Rights Reserved.
 */

 
#pragma once
 
 
#include "Constants.h"
 
 
#include <cmath>
#include <utility>
 

 

namespace YasiuMath {
    namespace Types {
        template<typename T>
        struct Point {
            T x = 0;
            T y = 0;
 
            Point( T x, T y )
                : x(x), y(y) {}
 
            Point( std::pair<T, T> point )
                : x(point.first), y(point.second) {}

            T fastAngle()
            {
                if ( x == 0.f ) {
                    return y;
                }
                else {
                    return static_cast<T>(atan2(y, x));
                }
            }
 
            T fastAngleModded()
            {
                // return fastAngle();
                return static_cast<T>(fmod(fastAngle(), static_cast<T>(YasiuMath::Constants::Y_PI)));
            }
        };
 

        template<typename U, typename T>
        struct IndexedPair {
            U index = 0;
            T first = 0;
            T second = 0;
 
            IndexedPair() = default;
 
            IndexedPair( U index, T first, T second )
                : index(index), first(first), second(second) {};
 
            Point<T> operator-( const IndexedPair<U, T>& other ) const
            {
                return Point<T>{first - other.first, second - other.second};
            }
 
            IndexedPair<U, T> subtract( const IndexedPair<U, T>& other ) const
            {
                return IndexedPair<U, T>{index, first - other.first, second - other.second};
            }
 
            bool operator==( const IndexedPair<U, T>& other ) const
            {
                return index == other.index;
            }
        };
 

        template<typename T>
        struct PointAngle {
            int index = 0;
            T angle = 0;
 
            PointAngle( const int& index, T angle )
                : index(index), angle(angle) {}
 
            PointAngle( const IndexedPair<int, T>& point )
            {
                index = point.index;
                angle = atan2(point.second, point.first);
            }
 
            PointAngle( const int& ind, const T& x, const T& y )
                : index(ind)
            {
                angle = atan2(y, x);
            }
 
            bool operator<( const PointAngle<T>& other ) const
            {
                return angle < other.angle;
            }
 
            bool operator>( const PointAngle<T>& other ) const
            {
                return angle > other.angle;
            }
        };
 

        template<typename T>
        struct Vec3 {
            T X = 0;
            T Y = 0;
            T Z = 0;
 
            Vec3() {};
 
            Vec3( T in )
                : X(in), Y(in), Z(in) {};
 
            Vec3( T xin, T yin, T zin )
                : X(xin), Y(yin), Z(zin) {};
 
            template<typename U>
            constexpr Vec3( const Vec3<U>& other )
                : X(static_cast<T>(other.X)), Y(static_cast<T>(other.Y)), Z(static_cast<T>(other.Z)) {}
 
 
            // Addition
            Vec3 operator+( const Vec3& other ) const
            {
                return Vec3(X + other.X, Y + other.Y, Z + other.Z);
            }
 
            Vec3& operator+=( const Vec3& other )
            {
                X += other.X;
                Y += other.Y;
                Z += other.Z;
                return *this;
            }
 
            // Subtraction
            Vec3 operator-( const Vec3& other ) const
            {
                return Vec3(X - other.X, Y - other.Y, Z - other.Z);
            }
 
            Vec3& operator-=( const Vec3& other )
            {
                X -= other.X;
                Y -= other.Y;
                Z -= other.Z;
                return *this;
            }
 
            // Scalar multiplication
            Vec3 operator*( T scalar ) const
            {
                return Vec3(X * scalar, Y * scalar, Z * scalar);
            }
 
            Vec3 operator*( Vec3 other ) const
            {
                return Vec3(X * other.X, Y * other.Y, Z * other.Z);
            }
 
            Vec3& operator*=( T scalar )
            {
                X *= scalar;
                Y *= scalar;
                Z *= scalar;
                return *this;
            }
 
            // Scalar division
            Vec3 operator/( T scalar ) const
            {
                return Vec3(X / scalar, Y / scalar, Z / scalar);
            }
 
            Vec3& operator/=( T scalar )
            {
                X /= scalar;
                Y /= scalar;
                Z /= scalar;
                return *this;
            }
 
            Vec3 operator/( const Vec3& other ) const
            {
                return Vec3(X / other.X, Y / other.Y, Z / other.Z);
            }
 
            Vec3& operator/=( const Vec3& other )
            {
                X /= other.X;
                Y /= other.Y;
                Z /= other.Z;
                return *this;
            }

            bool operator==( const Vec3& other ) const
            {
                return X == other.X && Y == other.Y && Z == other.Z;
            }

            bool operator!=( const Vec3& other ) const
            {
                return X != other.X || Y != other.Y || Z != other.Z;
            }

            bool operator>( const T value ) const
            {
                return Length() > value;
            }

            bool operator<( const T value ) const
            {
                return Length() < value;
            }

            bool operator>( const Vec3& other ) const
            {
                return LengthSquared() > other.LengthSquared();
            }

            bool operator<( const Vec3& other ) const
            {
                return LengthSquared() < other.LengthSquared();
            }

            T Dot( const Vec3& other ) const
            {
                return X * other.X + Y * other.Y + Z * other.Z;
            }

            Vec3 Cross( const Vec3& other ) const
            {
                return Vec3(Y * other.Z - Z * other.Y, Z * other.X - X * other.Z, X * other.Y - Y * other.X);
            }

            T LengthSquared() const
            {
                return X * X + Y * Y + Z * Z;
            }

            T Length() const
            {
                return static_cast<T>(std::sqrt(LengthSquared()));
            }

            Vec3 Abs() const
            {
                return Vec3{fabs(X), fabs(Y), fabs(Z)};
            }

            T Sum() const
            {
                return X + Y + Z;
            }

            T AbsSum() const
            {
                return fabs(X) + fabs(Y) + fabs(Z);
            }

            Vec3 Normalize() const
            {
                // Vec3 other = *this;
                // other.NormalizeInPlace();
                return Vec3(*this).NormalizeInPlace();
            }

            Vec3& NormalizeInPlace()
            {
                T len = Length();
                if ( len != 0 ) {
                    X /= len;
                    Y /= len;
                    Z /= len;
                }
                return *this;
            }

            bool IsNearly0( const T EPS = YasiuMath::Constants::EPSILON ) const
            {
                return AbsSum() < EPS;
            }
        };
    }
}