Cartesian.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cmath>
#include <iostream>
 
#include "NumCpp/NdArray.hpp"
#include "NumCpp/Utils/essentiallyEqual.hpp"
#include "NumCpp/Utils/sqr.hpp"
#include "NumCpp/Vector/Vec2.hpp"
#include "NumCpp/Vector/Vec3.hpp"
 
namespace nc::coordinates
{
    class Cartesian
    {
    public:
        double x{ 0. };
        double y{ 0. };
        double z{ 0. };
 
        Cartesian() noexcept = default;
 
        constexpr Cartesian(double inX, double inY, double inZ = 0.) noexcept :
            x(inX),
            y(inY),
            z(inZ)
        {
        }
        constexpr Cartesian(double inX, double inY, double inZ = 0.) noexcept : {…}
 
        Cartesian(const Vec2& inCartesianVector) :
            x(inCartesianVector.x),
            y(inCartesianVector.y)
        {
        }
        Cartesian(const Vec2& inCartesianVector) : {…}
 
        Cartesian(const Vec3& inCartesianVector) :
            x(inCartesianVector.x),
            y(inCartesianVector.y),
            z(inCartesianVector.z)
        {
        }
        Cartesian(const Vec3& inCartesianVector) : {…}
 
        //============================================================================
        Cartesian(const NdArray<double>& inCartesianVector)
        {
            if (inCartesianVector.size() != 3)
            {
                THROW_INVALID_ARGUMENT_ERROR("NdArray input must be of length 3.");
            }
 
            x = inCartesianVector[0];
            y = inCartesianVector[1];
            z = inCartesianVector[2];
        }
        Cartesian(const NdArray<double>& inCartesianVector) {…}
 
        Cartesian(const Cartesian& other) noexcept = default;
 
        Cartesian(Cartesian&& other) noexcept = default;
 
        virtual ~Cartesian() = default;
 
        Cartesian& operator=(const Cartesian& other) noexcept = default;
 
        Cartesian& operator=(Cartesian&& other) noexcept = default;
 
        [[nodiscard]] static Cartesian xHat() noexcept
        {
            return { 1., 0., 0. };
        }
        [[nodiscard]] static Cartesian xHat() noexcept {…}
 
        [[nodiscard]] static Cartesian yHat() noexcept
        {
            return { 0., 1., 0. };
        }
        [[nodiscard]] static Cartesian yHat() noexcept {…}
 
        [[nodiscard]] static Cartesian zHat() noexcept
        {
            return { 0., 0., 1. };
        }
        [[nodiscard]] static Cartesian zHat() noexcept {…}
 
        bool operator==(const Cartesian& other) const noexcept
        {
            return utils::essentiallyEqual(x, other.x) && utils::essentiallyEqual(y, other.y) &&
                   utils::essentiallyEqual(z, other.z);
        }
        bool operator==(const Cartesian& other) const noexcept {…}
 
        bool operator!=(const Cartesian& other) const noexcept
        {
            return !(*this == other);
        }
        bool operator!=(const Cartesian& other) const noexcept {…}
    };
    class Cartesian {…};
 
    [[nodiscard]] inline Cartesian operator+(const Cartesian& lhs, const Cartesian& rhs) noexcept
    {
        return { lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z };
    }
    [[nodiscard]] inline Cartesian operator+(const Cartesian& lhs, const Cartesian& rhs) noexcept {…}
 
    [[nodiscard]] inline Cartesian operator-(const Cartesian& lhs, const Cartesian& rhs) noexcept
    {
        return { lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z };
    }
    [[nodiscard]] inline Cartesian operator-(const Cartesian& lhs, const Cartesian& rhs) noexcept {…}
 
    [[nodiscard]] inline double operator*(const Cartesian& lhs, const Cartesian& rhs) noexcept
    {
        return lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z;
    }
    [[nodiscard]] inline double operator*(const Cartesian& lhs, const Cartesian& rhs) noexcept {…}
 
    [[nodiscard]] inline Cartesian operator*(double scalar, const Cartesian& vec) noexcept
    {
        return { vec.x * scalar, vec.y * scalar, vec.z * scalar };
    }
    [[nodiscard]] inline Cartesian operator*(double scalar, const Cartesian& vec) noexcept {…}
 
    [[nodiscard]] inline Cartesian operator*(const Cartesian& vec, double scalar) noexcept
    {
        return scalar * vec;
    }
    [[nodiscard]] inline Cartesian operator*(const Cartesian& vec, double scalar) noexcept {…}
 
    [[nodiscard]] inline Cartesian operator/(const Cartesian& vec, double denominator) noexcept
    {
        return vec * (1.0 / denominator);
    }
    [[nodiscard]] inline Cartesian operator/(const Cartesian& vec, double denominator) noexcept {…}
 
    inline std::ostream& operator<<(std::ostream& os, const Cartesian& vec)
    {
        os << "Cartesian(x=" << vec.x << ", y=" << vec.y << ", z=" << vec.z << ")\n";
        return os;
    }
    inline std::ostream& operator<<(std::ostream& os, const Cartesian& vec) {…}
 
    [[nodiscard]] inline Cartesian cross(const Cartesian& vec1, const Cartesian& vec2) noexcept
    {
        return { vec1.y * vec2.z - vec1.z * vec2.y,
                 -(vec1.x * vec2.z - vec1.z * vec2.x),
                 vec1.x * vec2.y - vec1.y * vec2.x };
    }
    [[nodiscard]] inline Cartesian cross(const Cartesian& vec1, const Cartesian& vec2) noexcept {…}
 
    [[nodiscard]] inline double norm(const Cartesian& vec) noexcept
    {
        return std::hypot(vec.x, vec.y, vec.z);
    }
    [[nodiscard]] inline double norm(const Cartesian& vec) noexcept {…}
 
    [[nodiscard]] inline Cartesian normalize(const Cartesian& vec) noexcept
    {
        return vec / norm(vec);
    }
    [[nodiscard]] inline Cartesian normalize(const Cartesian& vec) noexcept {…}
 
    [[nodiscard]] inline double angle(const Cartesian& vec1, const Cartesian& vec2) noexcept
    {
        return std::acos(normalize(vec1) * normalize(vec2));
    }
    [[nodiscard]] inline double angle(const Cartesian& vec1, const Cartesian& vec2) noexcept {…}
} // namespace nc::coordinates
namespace nc::coordinates {…}