Vector.hpp

//---- GPL ---------------------------------------------------------------------
//
// Copyright (C)  Stichting Deltares, 2011-2021.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation version 3.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
// contact: delft3d.support@deltares.nl
// Stichting Deltares
// P.O. Box 177
// 2600 MH Delft, The Netherlands
//
// All indications and logos of, and references to, "Delft3D" and "Deltares"
// are registered trademarks of Stichting Deltares, and remain the property of
// Stichting Deltares. All rights reserved.
//
//------------------------------------------------------------------------------
 
#pragma once
 
#include <array>
#include <cmath>
 
#include "MeshKernel/Constants.hpp"
 
namespace meshkernel
{
    class Vector
    {
    public:
        Vector() : m_values{constants::missing::doubleValue, constants::missing::doubleValue} {}
 
        Vector(const double x, const double y) : m_values{x, y} {}
 
        [[nodiscard]] double x() const
        {
            return m_values[0];
        }
 
        [[nodiscard]] double& x()
        {
            return m_values[0];
        }
 
        [[nodiscard]] double y() const
        {
            return m_values[1];
        }
        [[nodiscard]] double& y()
        {
            return m_values[1];
        }
 
        double operator[](const UInt i) const;
 
        double& operator[](const UInt i);
 
        Vector& operator+=(const Vector& vec);
 
        Vector& operator-=(const Vector& vec);
 
        Vector& operator/=(const double alpha);
 
        Vector& operator*=(const double alpha);
 
        void normalise();
 
        double length() const;
 
        double lengthSquared() const;
 
    private:
        std::array<double, 2> m_values;
    };
 
    Vector normalise(const Vector& vec);
 
    double dot(const Vector& v1, const Vector& v2);
 
    double angleBetween(const Vector& v1, const Vector& v2);
 
    Vector operator-(const Vector& vec);
 
    Vector operator+(const Vector& v1, const Vector& v2);
 
    Vector operator-(const Vector& v1, const Vector& v2);
 
    Vector operator*(const double alpha, const Vector& vec);
 
    Vector operator*(const Vector& vec, const double alpha);
 
    Vector operator/(const Vector& vec, const double alpha);
 
} // namespace meshkernel
 
inline double meshkernel::Vector::operator[](const UInt i) const
{
    return m_values[i];
}
 
inline double& meshkernel::Vector::operator[](const UInt i)
{
    return m_values[i];
}
 
inline meshkernel::Vector& meshkernel::Vector::operator+=(const Vector& vec)
{
    m_values[0] += vec.m_values[0];
    m_values[1] += vec.m_values[1];
    return *this;
}
 
inline meshkernel::Vector& meshkernel::Vector::operator-=(const Vector& vec)
{
    m_values[0] -= vec.m_values[0];
    m_values[1] -= vec.m_values[1];
    return *this;
}
 
inline meshkernel::Vector& meshkernel::Vector::operator/=(const double alpha)
{
    m_values[0] /= alpha;
    m_values[1] /= alpha;
    return *this;
}
 
inline meshkernel::Vector& meshkernel::Vector::operator*=(const double alpha)
{
    m_values[0] *= alpha;
    m_values[1] *= alpha;
    return *this;
}
 
inline void meshkernel::Vector::normalise()
{
    double lengthInv = 1.0 / length();
    m_values[0] *= lengthInv;
    m_values[1] *= lengthInv;
}
 
inline double meshkernel::Vector::length() const
{
    // TODO check implementation of hypot.
    return std::hypot(m_values[0], m_values[1]);
}
 
inline double meshkernel::Vector::lengthSquared() const
{
    return m_values[0] * m_values[0] + m_values[1] * m_values[1];
}
 
inline meshkernel::Vector meshkernel::normalise(const Vector& vec)
{
    double lengthInv = 1.0 / vec.length();
    Vector normalised(vec.x() * lengthInv, vec.y() * lengthInv);
    return normalised;
}
 
inline double meshkernel::dot(const Vector& v1, const Vector& v2)
{
    return v1.x() * v2.x() + v1.y() * v2.y();
}
 
inline double meshkernel::angleBetween(const Vector& v1, const Vector& v2)
{
    return std::atan2(v1.y() * v2.x() - v1.x() * v2.y(), v1.x() * v2.x() + v1.y() * v2.y());
}
 
inline meshkernel::Vector meshkernel::operator-(const Vector& vec)
{
    return Vector(-vec.x(), -vec.y());
}
 
inline meshkernel::Vector meshkernel::operator+(const Vector& v1, const Vector& v2)
{
    return Vector(v1.x() + v2.x(), v1.y() + v2.y());
}
 
inline meshkernel::Vector meshkernel::operator-(const Vector& v1, const Vector& v2)
{
    return Vector(v1.x() - v2.x(), v1.y() - v2.y());
}
 
inline meshkernel::Vector meshkernel::operator*(const double alpha, const Vector& vec)
{
    return Vector(alpha * vec.x(), alpha * vec.y());
}
 
inline meshkernel::Vector meshkernel::operator*(const Vector& vec, const double alpha)
{
    return alpha * vec;
}
 
inline meshkernel::Vector meshkernel::operator/(const Vector& vec, const double alpha)
{
    return Vector(vec.x() / alpha, vec.y() / alpha);
}