coordinate.hpp

#pragma once
 
#include <vector>
#include <array>
 
namespace LevelZ {
 
    struct Coordinate {
        virtual std::string to_string() const = 0;
 
        virtual double getMagnitude() const = 0;
    };
 
    struct Coordinate2D : Coordinate {
        public:
            double x;
 
            double y;
 
            Coordinate2D() : x(0), y(0) {}
 
            Coordinate2D(int x, int y) : x(x), y(y) {}
 
            Coordinate2D(double x, double y) : x(x), y(y) {}
 
            Coordinate2D(std::vector<int> xy) : x(xy.at(0)), y(xy.at(1)) {}
 
            Coordinate2D(std::array<int, 2> xy) : x(xy.at(0)), y(xy.at(1)) {}
 
            Coordinate2D(std::vector<double> xy) : x(xy.at(0)), y(xy.at(1)) {}
 
            Coordinate2D(std::array<double, 2> xy) : x(xy.at(0)), y(xy.at(1)) {}
 
            double getMagnitude() const {
                return x * x + y * y;
            }
 
            bool operator==(const Coordinate2D& other) const {
                return x == other.x && y == other.y;
            }
 
            bool operator!=(const Coordinate2D& other) const {
                return x != other.x || y != other.y;
            }
 
            Coordinate2D operator+(const Coordinate2D& other) const {
                return Coordinate2D(x + other.x, y + other.y);
            }
 
            Coordinate2D operator-(const Coordinate2D& other) const {
                return Coordinate2D(x - other.x, y - other.y);
            }
 
            Coordinate2D operator*(int scalar) const {
                return Coordinate2D(x * scalar, y * scalar);
            }
 
            Coordinate2D operator/(int scalar) const {
                return Coordinate2D(x / scalar, y / scalar);
            }
 
            std::string to_string() const {
                return "[" + std::to_string(x) + "," + std::to_string(y) + "]";
            }
 
            std::ostream& operator<<(std::ostream &strm) {
                return strm << to_string();
            }
 
            static Coordinate2D from_string(const std::string& str) {
                std::string x = str.substr(1, str.find(",") - 1);
                std::string y = str.substr(str.find(",") + 1, str.find("]") - str.find(",") - 1);
                return Coordinate2D(std::stod(x), std::stod(y));
            }
    };
 
    struct Coordinate3D : Coordinate {
        public:
            double x;
 
            double y;
 
            double z;
 
            Coordinate3D() : x(0), y(0), z(0) {}
 
            Coordinate3D(int x, int y, int z) : x(x), y(y), z(z) {}
 
            Coordinate3D(double x, double y, double z) : x(x), y(y), z(z) {}
 
            explicit Coordinate3D(std::vector<int> xyz) : x(xyz.at(0)), y(xyz.at(1)), z(xyz.at(2)) {}
 
            explicit Coordinate3D(std::array<int, 3> xyz) : x(xyz.at(0)), y(xyz.at(1)), z(xyz.at(2)) {}
 
            explicit Coordinate3D(std::vector<double> xyz) : x(xyz.at(0)), y(xyz.at(1)), z(xyz.at(2)) {}
 
            explicit Coordinate3D(std::array<double, 3> xyz) : x(xyz.at(0)), y(xyz.at(1)), z(xyz.at(2)) {}
 
            double getMagnitude() const {
                return x * x + y * y + z * z;
            }
 
            bool operator==(const Coordinate3D& other) const {
                return x == other.x && y == other.y && z == other.z;
            }
 
            bool operator!=(const Coordinate3D& other) const {
                return x != other.x || y != other.y || z != other.z;
            }
 
            Coordinate3D operator+(const Coordinate3D& other) const {
                return Coordinate3D(x + other.x, y + other.y, z + other.z);
            }
 
            Coordinate3D operator-(const Coordinate3D& other) const {
                return Coordinate3D(x - other.x, y - other.y, z - other.z);
            }
 
            Coordinate3D operator*(int scalar) const {
                return Coordinate3D(x * scalar, y * scalar, z * scalar);
            }
 
            Coordinate3D operator/(int scalar) const {
                return Coordinate3D(x / scalar, y / scalar, z / scalar);
            }
 
            std::string to_string() const {
                return "[" + std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "]";
            }
 
            std::ostream& operator<<(std::ostream &strm) {
                return strm << to_string();
            }
 
            static Coordinate3D from_string(const std::string& str) {
                std::string x = str.substr(1, str.find(",") - 1);
                std::string y = str.substr(str.find(",") + 1, str.rfind(",") - str.find(",") - 1);
                std::string z = str.substr(str.rfind(",") + 1, str.find("]") - str.rfind(",") - 1);
                return Coordinate3D(std::stod(x), std::stod(y), std::stod(z));
            }
    };
}