gdal_vectorx.h

/******************************************************************************
 * Project:  GDAL Vector abstraction
 * Purpose:
 * Author:   Javier Jimenez Shaw
 *
 ******************************************************************************
 * Copyright (c) 2024, Javier Jimenez Shaw
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/
 
#ifndef GDAL_VECTORX_H_INCLUDED
#define GDAL_VECTORX_H_INCLUDED

 
#include <algorithm>
#include <array>
#include <functional>
 
namespace gdal
{

template <typename T, std::size_t N> class VectorX
{
  public:
    using value_type = T;
    using size_type = std::size_t;
    using self_type = VectorX<T, N>;

    static constexpr size_type size() noexcept
    {
        return N;
    }
 
    VectorX()
    {
    }
 
    // cppcheck-suppress noExplicitConstructor
    template <typename... Args> VectorX(Args... args) : _values({args...})
    {
        static_assert(N == sizeof...(Args),
                      "Invalid number of constructor params");
    }

    const std::array<T, N> &array() const
    {
        return _values;
    }
 
    T &operator[](const size_type &pos)
    {
        return _values[pos];
    }
 
    const T &operator[](const size_type &pos) const
    {
        return _values[pos];
    }
 
    T x() const
    {
        static_assert(N >= 1, "Invalid template size for x()");
        return _values[0];
    }
 
    T y() const
    {
        static_assert(N >= 2, "Invalid template size for y()");
        return _values[1];
    }
 
    T z() const
    {
        static_assert(N >= 3, "Invalid template size for z()");
        return _values[2];
    }
 
    T &x()
    {
        static_assert(N >= 1, "Invalid template size for x()");
        return _values[0];
    }
 
    T &y()
    {
        static_assert(N >= 2, "Invalid template size for y()");
        return _values[1];
    }
 
    T &z()
    {
        static_assert(N >= 3, "Invalid template size for z()");
        return _values[2];
    }

    self_type &fill(T arg)
    {
        for (size_t i = 0; i < N; i++)
            (*this)[i] = arg;
 
        return *this;
    }

    template <class UnaryOp> self_type apply(UnaryOp op) const
    {
        self_type res;
        for (size_t i = 0; i < N; i++)
            res[i] = op(_values[i]);
        return res;
    }
 
    self_type floor() const
    {
        return apply([](const value_type &v) { return std::floor(v); });
    }
 
    self_type ceil() const
    {
        return apply([](const value_type &v) { return std::ceil(v); });
    }

    T scalarProd(const self_type &arg) const
    {
        T accum{};
        for (size_t i = 0; i < N; i++)
            accum += _values[i] * arg[i];
        return accum;
    }

    T norm2() const
    {
        return scalarProd(*this);
    }

    template <typename U> VectorX<U, N> cast() const
    {
        VectorX<U, N> res;
        for (size_t i = 0; i < N; i++)
            res[i] = static_cast<U>(_values[i]);
        return res;
    }
 
    self_type operator+(T arg) const
    {
        return operatorImpl<std::plus<T>>(arg);
    }
 
    self_type &operator+=(T arg)
    {
        return operatorEqImpl<std::plus<T>>(arg);
    }
 
    self_type operator-(T arg) const
    {
        return operatorImpl<std::minus<T>>(arg);
    }
 
    self_type &operator-=(T arg)
    {
        return operatorEqImpl<std::minus<T>>(arg);
    }
 
    self_type operator-() const
    {
        return apply([](const value_type &v) { return -v; });
    }
 
    template <typename U> self_type operator*(U arg) const
    {
        self_type res;
        for (size_t i = 0; i < N; i++)
            res[i] = T(_values[i] * arg);
        return res;
    }
 
    self_type operator*(T arg) const
    {
        return operatorImpl<std::multiplies<T>>(arg);
    }
 
    template <typename U> self_type operator/(U arg) const
    {
        self_type res;
        for (size_t i = 0; i < N; i++)
            res[i] = T(_values[i] / arg);
        return res;
    }
 
    self_type operator/(T arg) const
    {
        return operatorImpl<std::divides<T>>(arg);
    }
 
    self_type operator+(const self_type &arg) const
    {
        return operatorImpl<std::plus<T>>(arg);
    }
 
    self_type operator-(const self_type &arg) const
    {
        return operatorImpl<std::minus<T>>(arg);
    }
 
    friend VectorX<T, N> operator+(T t, const VectorX<T, N> &arg)
    {
        VectorX<T, N> res;
        for (size_t i = 0; i < N; i++)
            res._values[i] = t + arg._values[i];
        return res;
    }
 
    friend VectorX<T, N> operator-(T t, const VectorX<T, N> &arg)
    {
        VectorX<T, N> res;
        for (size_t i = 0; i < N; i++)
            res._values[i] = t - arg._values[i];
        return res;
    }
 
  private:
    std::array<T, N> _values{};
 
    template <class Op> self_type operatorImpl(T arg) const
    {
        self_type res;
        auto op = Op();
        for (size_t i = 0; i < N; i++)
            res[i] = op(_values[i], arg);
        return res;
    }
 
    template <class Op> self_type &operatorEqImpl(T arg)
    {
        auto op = Op();
        for (size_t i = 0; i < N; i++)
            _values[i] = op(_values[i], arg);
        return *this;
    }
 
    template <class Op> self_type operatorImpl(const self_type &arg) const
    {
        self_type res;
        auto op = Op();
        for (size_t i = 0; i < N; i++)
            res[i] = op(_values[i], arg[i]);
        return res;
    }
 
    template <class Op> self_type &operatorEqImpl(const self_type &arg)
    {
        auto op = Op();
        for (size_t i = 0; i < N; i++)
            _values[i] = op(_values[i], arg[i]);
        return *this;
    }
};
 
using Vector2d = VectorX<double, 2>;
using Vector2i = VectorX<int, 2>;
using Vector3d = VectorX<double, 3>;
using Vector3i = VectorX<int, 3>;
}  // namespace gdal

 
#endif /* ndef GDAL_VECTORX_H_INCLUDED */