TemplatePoint.h

Go to the documentation of this file.

 
#pragma once
 
#include "mathlib_export.h"
 
// STL
#include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <istream>
#include <iterator>
#include <utility>
 
namespace MathLib
{
template <typename T, std::size_t DIM = 3> class TemplatePoint
{
public:
    TemplatePoint();
 
    explicit TemplatePoint(std::array<T, DIM> x);
 
    virtual ~TemplatePoint() = default;
 
    TemplatePoint(TemplatePoint const&) = default;
    TemplatePoint& operator=(TemplatePoint const&) = default;
 
    const T& operator[] (std::size_t idx) const
    {
        assert (idx < DIM);
        return x_[idx];
    }
    T& operator[] (std::size_t idx)
    {
        return const_cast<T&> (static_cast<const TemplatePoint&> (*this)[idx]);
    }
 
    const T* getCoords() const { return x_.data(); }
 
    T* getCoords() { return x_.data(); }
 
    virtual void write (std::ostream &os) const
    {
        std::copy(x_.cbegin(), x_.cend(), std::ostream_iterator<T>(os, " "));
    }
 
    virtual void read (std::istream &is)
    {
        std::copy(std::istream_iterator<T>(is), std::istream_iterator<T>(),
                  x_.begin());
    }
 
private:
    std::array<T, DIM> x_;
};
 
template <typename T, std::size_t DIM>
TemplatePoint<T, DIM>::TemplatePoint() : x_({{0}})
{}
 
template <typename T, std::size_t DIM>
TemplatePoint<T, DIM>::TemplatePoint(std::array<T, DIM> x) : x_(std::move(x))
{}
 
template <typename T, std::size_t DIM>
bool operator==(TemplatePoint<T,DIM> const& a, TemplatePoint<T,DIM> const& b)
{
    T const sqr_dist(sqrDist(a,b));
    auto const eps = std::numeric_limits<T>::epsilon();
    return (sqr_dist < eps*eps);
}
 
template <typename T, std::size_t DIM>
bool operator< (TemplatePoint<T,DIM> const& a, TemplatePoint<T,DIM> const& b)
{
    for (std::size_t i = 0; i < DIM; ++i)
    {
        if (a[i] > b[i]) {
            return false;
        }
        if (a[i] < b[i])
        {
            return true;
            }
 
        // continue with next dimension, because a[0] == b[0]
    }
 
    // The values in all dimenisions are equal.
    return false;
}
 
template <typename T, std::size_t DIM>
bool lessEq(TemplatePoint<T, DIM> const& a, TemplatePoint<T, DIM> const& b,
        double eps = std::numeric_limits<double>::epsilon())
{
    auto coordinateIsLargerEps = [&eps](T const u, T const v) -> bool
    {
        return std::abs(u - v) > eps * std::min(std::abs(v), std::abs(u)) &&
               std::abs(u - v) > eps;
    };
 
    for (std::size_t i = 0; i < DIM; ++i)
    {
        // test a relative and an absolute criterion
        if (coordinateIsLargerEps(a[i], b[i]))
        {
            return static_cast<bool>(a[i] <= b[i]);
        }
        // a[i] ~= b[i] up to an epsilon. Compare next dimension.
    }
 
    // all coordinates are equal up to an epsilon.
    return true;
}
 
template <typename T, std::size_t DIM>
std::ostream& operator<< (std::ostream &os, const TemplatePoint<T,DIM> &p)
{
    p.write (os);
    return os;
}
 
template <typename T, std::size_t DIM>
std::istream& operator>> (std::istream &is, TemplatePoint<T,DIM> &p)
{
    p.read (is);
    return is;
}
} // end namespace MathLib