vcl::PointConcept Concept Reference

Concept for types representing points in Euclidean space. More...

#include <vclib/concepts/space/point.h>

Concept definition

template<typename T>
concept vcl::PointConcept =  requires (
    T&&                                    obj,
    typename RemoveRef<T>::ScalarType      s,
    typename RemoveRef<T>::ScalarType&     sR,
    typename RemoveRef<T>::BaseMatrixType& baseObjR) {
    
    typename RemoveRef<T>::ScalarType;
    typename RemoveRef<T>::BaseMatrixType;
 
    obj.DIM;
 
    RemoveRef<T>();
    RemoveRef<T>(obj);
 
    { obj.isDegenerate() } -> std::same_as<bool>;
    { obj.dot(obj) } -> std::same_as<decltype(s)>;
    { obj.angle(obj) } -> std::same_as<decltype(s)>;
    { obj.dist(obj) } -> std::same_as<decltype(s)>;
    { obj.squaredDist(obj) } -> std::same_as<decltype(s)>;
    { obj.norm() } -> std::same_as<decltype(s)>;
    { obj.squaredNorm() } -> std::same_as<decltype(s)>;
    { obj.size() } -> std::same_as<uint>;
 
    { obj.hash() } -> std::same_as<std::size_t>;
 
    { obj(uint()) } -> std::convertible_to<decltype(s)>;
    { obj[uint()] } -> std::convertible_to<decltype(s)>;
 
    { obj == obj } -> std::same_as<bool>;
    { obj <=> obj } -> std::convertible_to<std::partial_ordering>;
 
    { obj.normalized() } -> std::convertible_to<RemoveRef<T>>;
    { obj + s } -> std::convertible_to<RemoveRef<T>>;
    { obj + obj } -> std::convertible_to<RemoveRef<T>>;
 
    { -obj } -> std::convertible_to<RemoveRef<T>>;
    { obj - s } -> std::convertible_to<RemoveRef<T>>;
    { obj - obj } -> std::convertible_to<RemoveRef<T>>;
 
    { obj* s } -> std::convertible_to<RemoveRef<T>>;
 
    { obj / s } -> std::convertible_to<RemoveRef<T>>;
 
    
    requires IsConst<T> || requires {
        { obj.setConstant(s) } -> std::same_as<decltype(baseObjR)>;
        { obj.setZero() } -> std::same_as<decltype(baseObjR)>;
        { obj.setOnes() } -> std::same_as<decltype(baseObjR)>;
        { obj.normalize() } -> std::same_as<void>;
 
        { obj(uint()) } -> std::same_as<decltype(sR)>;
        { obj[uint()] } -> std::same_as<decltype(sR)>;
 
        { obj = obj } -> std::same_as<T&>;
 
        { obj += s } -> std::same_as<T&>;
        { obj += obj } -> std::same_as<decltype(baseObjR)>;
 
        { obj -= s } -> std::same_as<T&>;
        { obj -= obj } -> std::same_as<decltype(baseObjR)>;
 
        { obj *= s } -> std::same_as<decltype(baseObjR)>;
        { obj /= s } -> std::same_as<decltype(baseObjR)>;
    };
}

Detailed Description

Concept for types representing points in Euclidean space.

Template Parameters

T	The type to be tested for conformity to the PointConcept.