MeshLib C++ Docs
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Friends | List of all members
MR::Vector2< T > Struct Template Reference
Math group » Vector

#include <MRMesh/MRVector2.h>

Public Types

using ValueType = T
using MatrixType = Matrix2<T>
using SymMatrixType = SymMatrix2<T>

Public Member Functions

constexpr Vector2 () noexcept
 Vector2 (NoInit) noexcept
constexpr Vector2 (T x, T y) noexcept
template<typename U>
 MR_REQUIRES_IF_SUPPORTED (std::constructible_from< T, U >) explicit const expr Vector2(const Vector3< U > &v) noexcept
template<typename U>
 MR_REQUIRES_IF_SUPPORTED (!std::is_same_v< T, U >) const expr explicit Vector2(const Vector2< U > &v) noexcept
constexpr const T & operator[] (int e) const noexcept
constexpr T & operator[] (int e) noexcept
T lengthSq () const
auto length () const
Vector2 normalized () const MR_REQUIRES_IF_SUPPORTED(!std
Vector2 furthestBasisVector() const MR_REQUIRES_IF_SUPPORTED(!std constexpr Vector2 perpendicular () const MR_REQUIRES_IF_SUPPORTED(!std
 returns one of 2 basis unit vector that makes the biggest angle with the direction specified by this
bool isFinite () const MR_REQUIRES_IF_SUPPORTED(std

Static Public Member Functions

static constexpr Vector2 diagonal (T a) noexcept
static constexpr Vector2 plusX () noexcept
static constexpr Vector2 plusY () noexcept
static constexpr Vector2 minusX () noexcept MR_REQUIRES_IF_SUPPORTED(!std
static constexpr Vector2 minusY () noexcept MR_REQUIRES_IF_SUPPORTED(!std

Public Attributes

T x
T y

Static Public Attributes

static constexpr int elements = 2

Friends

constexpr bool operator== (const Vector2< T > &a, const Vector2< T > &b)
constexpr bool operator!= (const Vector2< T > &a, const Vector2< T > &b)
constexpr const Vector2< T > & operator+ (const Vector2< T > &a)
 NOTE: We use std::declval() in the operators below because libclang 18 in our binding generator is bugged and chokes on decltyping a.x and such. TODO fix this when we update libclang.
constexpr auto operator- (const Vector2< T > &a) -> Vector2< decltype(-std::declval< T >())>
constexpr auto operator+ (const Vector2< T > &a, const Vector2< T > &b) -> Vector2< decltype(std::declval< T >()+std::declval< T >())>
constexpr auto operator- (const Vector2< T > &a, const Vector2< T > &b) -> Vector2< decltype(std::declval< T >() - std::declval< T >())>
constexpr auto operator* (T a, const Vector2< T > &b) -> Vector2< decltype(std::declval< T >() *std::declval< T >())>
constexpr auto operator* (const Vector2< T > &b, T a) -> Vector2< decltype(std::declval< T >() *std::declval< T >())>
constexpr auto operator/ (Vector2< T > b, T a) -> Vector2< decltype(std::declval< T >()/std::declval< T >())>
constexpr Vector2< T > & operator+= (Vector2< T > &a, const Vector2< T > &b)
constexpr Vector2< T > & operator-= (Vector2< T > &a, const Vector2< T > &b)
constexpr Vector2< T > & operator*= (Vector2< T > &a, T b)
constexpr Vector2< T > & operator/= (Vector2< T > &a, T b)
std::ostream & operator<< (std::ostream &s, const Vector2 &vec)
std::istream & operator>> (std::istream &s, Vector2 &vec)
MR_BIND_IGNORE friend auto begin (const Vector2 &v)
MR_BIND_IGNORE friend auto begin (Vector2 &v)
MR_BIND_IGNORE friend auto end (const Vector2 &v)
MR_BIND_IGNORE friend auto end (Vector2 &v)

(Note that these are not member symbols.)

template<typename T>
T distanceSq (const Vector2< T > &a, const Vector2< T > &b)
 squared distance between two points, which is faster to compute than just distance
template<typename T>
T distance (const Vector2< T > &a, const Vector2< T > &b)
 distance between two points, better use distanceSq for higher performance
template<typename T>
T cross (const Vector2< T > &a, const Vector2< T > &b)
 cross product
template<typename T>
auto dot (const Vector2< T > &a, const Vector2< T > &b) -> decltype(a.x *b.x)
 dot product
template<typename T>
T sqr (const Vector2< T > &a)
 squared length
template<typename T>
Vector2< T > mult (const Vector2< T > &a, const Vector2< T > &b)
 per component multiplication
template<typename T>
Vector2< T > div (const Vector2< T > &a, const Vector2< T > &b)
 per component division
template<typename T>
T angle (const Vector2< T > &a, const Vector2< T > &b)
 angle in radians between two vectors

Detailed Description

template<typename T>
struct MR::Vector2< T >

two-dimensional vector

Member Typedef Documentation

◆ MatrixType

template<typename T>
using MR::Vector2< T >::MatrixType = Matrix2<T>

◆ SymMatrixType

template<typename T>
using MR::Vector2< T >::SymMatrixType = SymMatrix2<T>

◆ ValueType

template<typename T>
using MR::Vector2< T >::ValueType = T

Constructor & Destructor Documentation

◆ Vector2() [1/3]

template<typename T>
MR::Vector2< T >::Vector2 ( )
inlineconstexprnoexcept

◆ Vector2() [2/3]

template<typename T>
MR::Vector2< T >::Vector2 ( NoInit )
inlineexplicitnoexcept

◆ Vector2() [3/3]

template<typename T>
MR::Vector2< T >::Vector2 ( T x,
T y )
inlineconstexprnoexcept

Member Function Documentation

◆ diagonal()

template<typename T>
constexpr Vector2 MR::Vector2< T >::diagonal ( T a)
inlinestaticconstexprnoexcept

◆ isFinite()

template<typename T>
bool MR::Vector2< T >::isFinite ( ) const
inlinenodiscard

◆ length()

template<typename T>
auto MR::Vector2< T >::length ( ) const
inline

Calling sqrt this way to hopefully support boost.multiprecision numbers. Returning auto to not break on integral types.

◆ lengthSq()

template<typename T>
T MR::Vector2< T >::lengthSq ( ) const
inline

◆ minusX()

template<typename T>
constexpr Vector2 MR::Vector2< T >::minusX ( )
inlinestaticconstexprnoexcept

◆ minusY()

template<typename T>
constexpr Vector2 MR::Vector2< T >::minusY ( )
inlinestaticconstexprnoexcept

◆ MR_REQUIRES_IF_SUPPORTED() [1/2]

template<typename T>
template<typename U>
MR::Vector2< T >::MR_REQUIRES_IF_SUPPORTED ( !std::is_same_v< T, U > ) const &
inlinenoexcept

Here T == U doesn't seem to cause any issues in the C++ code, but we're still disabling it because it somehow gets emitted when generating the bindings, and looks out of place there.

◆ MR_REQUIRES_IF_SUPPORTED() [2/2]

template<typename T>
template<typename U>
MR::Vector2< T >::MR_REQUIRES_IF_SUPPORTED ( std::constructible_from< T, U > ) const &
inlinenoexcept

◆ normalized()

template<typename T>
Vector2 MR::Vector2< T >::normalized ( ) const
inline

◆ operator[]() [1/2]

template<typename T>
const T & MR::Vector2< T >::operator[] ( int e) const
inlineconstexprnoexcept

◆ operator[]() [2/2]

template<typename T>
T & MR::Vector2< T >::operator[] ( int e)
inlineconstexprnoexcept

◆ perpendicular()

template<typename T>
Vector2 furthestBasisVector() const MR_REQUIRES_IF_SUPPORTED(!std constexpr Vector2 MR::Vector2< T >::perpendicular ( ) const
inlineconstexpr

returns one of 2 basis unit vector that makes the biggest angle with the direction specified by this

returns same length vector orthogonal to this (rotated 90 degrees counter-clockwise)

◆ plusX()

template<typename T>
constexpr Vector2 MR::Vector2< T >::plusX ( )
inlinestaticconstexprnoexcept

◆ plusY()

template<typename T>
constexpr Vector2 MR::Vector2< T >::plusY ( )
inlinestaticconstexprnoexcept

◆ angle()

template<typename T>
T angle ( const Vector2< T > & a,
const Vector2< T > & b )
related

angle in radians between two vectors

this version is slower and less precise return std::acos( std::clamp( dot( a.normalized(), b.normalized() ), T(-1), T(1) ) );

◆ begin [1/2]

template<typename T>
MR_BIND_IGNORE friend auto begin ( const Vector2< T > & v)
friend

We don't need to bind those functions in Python, because this doesn't prevent __iter__ from being generated for the type. Those don't bind correctly in C#, because there we can't overload functions based on mutable struct ref vs const struct ref parameters.

◆ begin [2/2]

template<typename T>
MR_BIND_IGNORE friend auto begin ( Vector2< T > & v)
friend

◆ cross()

template<typename T>
T cross ( const Vector2< T > & a,
const Vector2< T > & b )
related

cross product

◆ distance()

template<typename T>
T distance ( const Vector2< T > & a,
const Vector2< T > & b )
related

distance between two points, better use distanceSq for higher performance

◆ distanceSq()

template<typename T>
T distanceSq ( const Vector2< T > & a,
const Vector2< T > & b )
related

squared distance between two points, which is faster to compute than just distance

◆ div()

template<typename T>
Vector2< T > div ( const Vector2< T > & a,
const Vector2< T > & b )
related

per component division

◆ dot()

template<typename T>
auto dot ( const Vector2< T > & a,
const Vector2< T > & b ) -> decltype( a.x * b.x )
related

dot product

◆ end [1/2]

template<typename T>
MR_BIND_IGNORE friend auto end ( const Vector2< T > & v)
friend

◆ end [2/2]

template<typename T>
MR_BIND_IGNORE friend auto end ( Vector2< T > & v)
friend

◆ mult()

template<typename T>
Vector2< T > mult ( const Vector2< T > & a,
const Vector2< T > & b )
related

per component multiplication

◆ operator!=

template<typename T>
bool operator!= ( const Vector2< T > & a,
const Vector2< T > & b )
friend

◆ operator* [1/2]

template<typename T>
auto operator* ( const Vector2< T > & b,
T a ) -> Vector2<decltype( std::declval<T>() * std::declval<T>() )>
friend

◆ operator* [2/2]

template<typename T>
auto operator* ( T a,
const Vector2< T > & b ) -> Vector2<decltype( std::declval<T>() * std::declval<T>() )>
friend

◆ operator*=

template<typename T>
Vector2< T > & operator*= ( Vector2< T > & a,
T b )
friend

◆ operator+ [1/2]

template<typename T>
const Vector2< T > & operator+ ( const Vector2< T > & a)
friend

NOTE: We use std::declval() in the operators below because libclang 18 in our binding generator is bugged and chokes on decltyping a.x and such. TODO fix this when we update libclang.

◆ operator+ [2/2]

template<typename T>
auto operator+ ( const Vector2< T > & a,
const Vector2< T > & b ) -> Vector2<decltype( std::declval<T>() + std::declval<T>() )>
friend

◆ operator+=

template<typename T>
Vector2< T > & operator+= ( Vector2< T > & a,
const Vector2< T > & b )
friend

◆ operator- [1/2]

template<typename T>
auto operator- ( const Vector2< T > & a) -> Vector2<decltype( -std::declval<T>() )>
friend

◆ operator- [2/2]

template<typename T>
auto operator- ( const Vector2< T > & a,
const Vector2< T > & b ) -> Vector2<decltype( std::declval<T>() - std::declval<T>() )>
friend

◆ operator-=

template<typename T>
Vector2< T > & operator-= ( Vector2< T > & a,
const Vector2< T > & b )
friend

◆ operator/

template<typename T>
auto operator/ ( Vector2< T > b,
T a ) -> Vector2<decltype( std::declval<T>() / std::declval<T>() )>
friend

◆ operator/=

template<typename T>
Vector2< T > & operator/= ( Vector2< T > & a,
T b )
friend

◆ operator<<

template<typename T>
std::ostream & operator<< ( std::ostream & s,
const Vector2< T > & vec )
friend

◆ operator==

template<typename T>
bool operator== ( const Vector2< T > & a,
const Vector2< T > & b )
friend

◆ operator>>

template<typename T>
std::istream & operator>> ( std::istream & s,
Vector2< T > & vec )
friend

◆ sqr()

template<typename T>
T sqr ( const Vector2< T > & a)
related

squared length

Member Data Documentation

◆ elements

template<typename T>
int MR::Vector2< T >::elements = 2
staticconstexpr

◆ x

template<typename T>
T MR::Vector2< T >::x

◆ y

template<typename T>
T MR::Vector2< T >::y
The documentation for this struct was generated from the following file: