vector.h

#include "util.h"
#ifndef VECTOR_H
#define VECTOR_H

#include <cmath>
#include <stdexcept>
#include <random>
#include <ostream>

using namespace std;

/**************
 *Description:
 *Input:
 *Output:
**************/

struct VectorF;

struct VectorI //integer vector
{
    int x, y, z;
    constexpr VectorI(int x, int y, int z)
        : x(x), y(y), z(z)
    {
    }

private:
    VectorI(float x, float y, float z) = delete;
public:

    constexpr VectorI(int v = 0)
        : x(v), y(v), z(v)
    {
    }

    constexpr const VectorI operator -() const //switching sign
    {
        return VectorI(-x, -y, -z);
    }

    constexpr const VectorI &operator +() const
    {
        return *this;
    }

    constexpr const VectorI operator +(const VectorI &r) const  //addition
    {
        return VectorI(x + r.x, y + r.y, z + r.z);
    }

    constexpr const VectorI operator -(const VectorI &r) const  //subtraction
    {
        return VectorI(x - r.x, y - r.y, z - r.z);
    }

    constexpr const VectorI operator *(const VectorI &r) const  //multiplication
    {
        return VectorI(x * r.x, y * r.y, z * r.z);
    }

    constexpr const VectorI operator *(int r) const//scalar multiplication
    {
        return VectorI(x * r, y * r, z * r);
    }

    friend constexpr  VectorI operator *(int a, const VectorI &b)  //multiplication
    {
        return VectorI(a * b.x, a * b.y, a * b.z);
    }

    constexpr bool operator ==(const VectorI &r) const  //comparison
    {
        return x == r.x && y == r.y && z == r.z;
    }

    constexpr bool operator !=(const VectorI &r) const  //inequality
    {
        return x != r.x || y != r.y || z != r.z;
    }

    const VectorI &operator +=(const VectorI &r)   //adding to itself
    {
        x += r.x;
        y += r.y;
        z += r.z;
        return *this;
    }
    const VectorI &operator -=(const VectorI &r)  //subtracting to itself
    {
        x -= r.x;
        y -= r.y;
        z -= r.z;
        return *this;
    }
    const VectorI &operator *=(const VectorI &r)  //multiplying to itself
    {
        x *= r.x;
        y *= r.y;
        z *= r.z;
        return *this;
    }
    const VectorI &operator *=(int r)  //multiplying by itself
    {
        x *= r;
        y *= r;
        z *= r;
        return *this;
    }

    friend constexpr int dot(const VectorI &a, const VectorI &b)  //dot product
    {
        return a.x * b.x + a.y * b.y + a.z * b.z;
    }

    friend constexpr int absSquared(const VectorI &v) //length squared
    {
        return dot(v, v);
    }

    friend float abs(const VectorI &v) //length
    {
        return sqrt(absSquared(v));
    }

    friend constexpr VectorI cross(const VectorI &a, const VectorI &b)  //cross product
    {
        return VectorI(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
    }

    friend ostream &operator <<(ostream &os, const VectorI &v)   //prints vector
    {
        return os << "<" << v.x << ", " << v.y << ", " << v.z << ">";
    }
};

struct VectorF //floating point vector
{
    float x, y, z;

    constexpr VectorF(float x, float y, float z)//constructor
        : x(x), y(y), z(z)
    {
    }

    constexpr VectorF(float v = 0)//constructor for the origin
        : x(v), y(v), z(v)
    {
    }

    constexpr VectorF(const VectorI &v) //converts integer vector to float vector
        : x(v.x), y(v.y), z(v.z)
    {
    }

    explicit operator VectorI() const //sets vector to lowest it can be
    {
        return VectorI(ifloor(x), ifloor(y), ifloor(z));
    }

    constexpr const VectorF operator -() const//negates a vector
    {
        return VectorF(-x, -y, -z);
    }

    constexpr const VectorF &operator +() const //leaves a vector positive
    {
        return *this;
    }

    constexpr const VectorF operator +(const VectorF &r) const //adds two vectors
    {
        return VectorF(x + r.x, y + r.y, z + r.z);
    }

    friend constexpr VectorF operator +(const VectorF &l,
                                        const VectorI &r)  //adds int and float vectors
    {
        return l + (VectorF)r;
    }

    friend constexpr VectorF operator +(const VectorI &l,
                                        const VectorF &r)  //adds int and float vectors
    {
        return (VectorF)l + r;
    }

    constexpr const VectorF operator -(const VectorF &r) const
    {
        return VectorF(x - r.x, y - r.y, z - r.z);
    }

    friend constexpr VectorF operator -(const VectorF &l, const VectorI &r)
    {
        return l - (VectorF)r;
    }

    friend constexpr VectorF operator -(const VectorI &l, const VectorF &r)
    {
        return (VectorF)l - r;
    }

    constexpr const VectorF operator *(const VectorF &r) const
    {
        return VectorF(x * r.x, y * r.y, z * r.z);
    }

    friend constexpr VectorF operator *(const VectorF &l, const VectorI &r)
    {
        return l * (VectorF)r;
    }

    friend constexpr VectorF operator *(const VectorI &l, const VectorF &r)
    {
        return (VectorF)l * r;
    }

    constexpr const VectorF operator /(const VectorF &r) const
    {
        return VectorF(x / r.x, y / r.y, z / r.z);
    }

    constexpr const VectorF operator *(float r) const
    {
        return VectorF(x * r, y * r, z * r);
    }

    friend constexpr VectorF operator *(float a, const VectorF &b)
    {
        return VectorF(a * b.x, a * b.y, a * b.z);
    }

    constexpr const VectorF operator /(float r) const
    {
        return VectorF(x / r, y / r, z / r);
    }

    constexpr bool operator ==(const VectorF &r) const
    {
        return x == r.x && y == r.y && z == r.z;
    }

    constexpr bool operator !=(const VectorF &r) const
    {
        return x != r.x || y != r.y || z != r.z;
    }

    const VectorF &operator +=(const VectorF &r)
    {
        x += r.x;
        y += r.y;
        z += r.z;
        return *this;
    }
    const VectorF &operator -=(const VectorF &r)
    {
        x -= r.x;
        y -= r.y;
        z -= r.z;
        return *this;
    }
    const VectorF &operator *=(const VectorF &r)
    {
        x *= r.x;
        y *= r.y;
        z *= r.z;
        return *this;
    }
    const VectorF &operator /=(const VectorF &r)
    {
        x /= r.x;
        y /= r.y;
        z /= r.z;
        return *this;
    }
    const VectorF &operator *=(float r)
    {
        x *= r;
        y *= r;
        z *= r;
        return *this;
    }
    const VectorF &operator /=(float r)
    {
        x /= r;
        y /= r;
        z /= r;
        return *this;
    }

    friend constexpr float dot(const VectorF &a, const VectorF &b)
    {
        return a.x * b.x + a.y * b.y + a.z * b.z;
    }

    friend constexpr float dot(const VectorI &a, const VectorF &b)
    {
        return a.x * b.x + a.y * b.y + a.z * b.z;
    }

    friend constexpr float dot(const VectorF &a, const VectorI &b)
    {
        return a.x * b.x + a.y * b.y + a.z * b.z;
    }

    friend constexpr float absSquared(const VectorF &v)
    {
        return dot(v, v);
    }

    friend float abs(const VectorF &v)
    {
        return sqrt(absSquared(v));
    }

    friend const VectorF normalizeNoThrow(const VectorF &v)
    {
        float r = abs(v);

        if(r == 0)
        {
            r = 1;
        }

        return v / r;
    }

    friend const VectorF normalize(const VectorF v)
    {
        float r = abs(v);

        if(v == 0)
        {
            throw domain_error("can't normalize <0, 0, 0>");
        }

        return v / r;
    }

    const VectorF static normalize(float x, float y, float z)
    {
        VectorF v(x, y, z);
        float r = abs(v);

        if(v == 0)
        {
            throw domain_error("can't normalize <0, 0, 0>");
        }

        return v / r;
    }

    float phi() const
    {
        float r = abs(*this);

        if(r == 0)
        {
            return 0;
        }

        float v = y / r;
        v = limit(v, -1.0f, 1.0f);
        return asin(v);
    }

    float theta() const
    {
        return atan2(x, z);
    }

    float rSpherical() const
    {
        return abs(*this);
    }

    friend constexpr VectorF cross(const VectorF &a, const VectorF &b)
    {
        return VectorF(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
    }

    template<typename RE>
    static VectorF random(RE &re)
    {
        VectorF retval;

        do
        {
            retval.x = uniform_real_distribution<float>(-1, 1)(re);
            retval.y = uniform_real_distribution<float>(-1, 1)(re);
            retval.z = uniform_real_distribution<float>(-1, 1)(re);
        }
        while(absSquared(retval) > 1 || absSquared(retval) < eps);

        return retval;
    }

    friend ostream &operator <<(ostream &os, const VectorF &v)
    {
        return os << "<" << v.x << ", " << v.y << ", " << v.z << ">";
    }
};

constexpr inline bool operator ==(const VectorF &a, const VectorI &b)
{
    return a.x == b.x && a.y == b.y && a.z == b.z;
}

constexpr inline bool operator ==(const VectorI &a, const VectorF &b)
{
    return a.x == b.x && a.y == b.y && a.z == b.z;
}

constexpr inline bool operator !=(const VectorF &a, const VectorI &b)
{
    return a.x != b.x || a.y != b.y || a.z != b.z;
}

constexpr inline bool operator !=(const VectorI &a, const VectorF &b)
{
    return a.x != b.x || a.y != b.y || a.z != b.z;
}

inline VectorF normalize(const VectorI &v)
{
    return normalize((VectorF)v);
}

inline VectorF normalizeNoThrow(const VectorI &v)
{
    return normalizeNoThrow((VectorF)v);
}

constexpr VectorF gravityVector = VectorF(0, -9.8, 0);

inline float findIntersectionPoint(VectorF a, VectorF b, VectorF normal, float d)
{
    return (dot(a, normal) + d) / dot(a - b, normal);
}

inline VectorF findTriplePlaneIntersection(VectorF normal1, float d1, VectorF normal2, float d2,
        VectorF normal3, float d3)
{
    float a1 = normal1.x;
    float b1 = normal1.y;
    float c1 = normal1.z;
    float a2 = normal2.x;
    float b2 = normal2.y;
    float c2 = normal2.z;
    float a3 = normal3.x;
    float b3 = normal3.y;
    float c3 = normal3.z;
    float x = -(b3 * c2 * d1 - b2 * c3 * d1 - b3 * c1 * d2 + b1 * c3 * d2 + b2 * c1 * d3 - b1 * c2 *
                d3) / (a3 * b2 * c1 - a2 * b3 * c1 - a3 * b1 * c2 + a1 * b3 * c2 + a2 * b1 * c3 - a1 * b2 * c3);
    float y = -(-a3 * c2 * d1 + a2 * c3 * d1 + a3 * c1 * d2 - a1 * c3 * d2 - a2 * c1 * d3 + a1 * c2 *
                d3) / (a3 * b2 * c1 - a2 * b3 * c1 - a3 * b1 * c2 + a1 * b3 * c2 + a2 * b1 * c3 - a1 * b2 * c3);
    float z = -(a3 * b2 * d1 - a2 * b3 * d1 - a3 * b1 * d2 + a1 * b3 * d2 + a2 * b1 * d3 - a1 * b2 *
                d3) / (a3 * b2 * c1 - a2 * b3 * c1 - a3 * b1 * c2 + a1 * b3 * c2 + a2 * b1 * c3 - a1 * b2 * c3);
    return VectorF(x, y, z);
}

namespace std
{
template <>
struct hash<VectorF>
{
    size_t operator ()(const VectorF & p) const
    {
        return hash<float>()(p.x) + hash<float>()(p.y) + hash<float>()(p.z);
    }
};
}

#endif // VECTOR_H