CubbyFlow-v1/doxygen/_vector2-_impl_8h_source.html

 /*************************************************************************
 > File Name: Vector2-Impl.h
 > Project Name: CubbyFlow
 > Author: Dongmin Kim
 > Purpose: 2-D vector class.
 > Created Time: 2017/02/21
 > Copyright (c) 2018, Dongmin Kim
 *************************************************************************/
 #ifndef CUBBYFLOW_VECTOR2_IMPL_H
 #define CUBBYFLOW_VECTOR2_IMPL_H

 #include <Core/Math/MathUtils.h>

 #include <cassert>
 #include <limits>

 namespace CubbyFlow
 {
     // Constructors
     template <typename T>
     template <typename U>
     Vector<T, 2>::Vector(const std::initializer_list<U>& list)
     {
         Set(list);
     }

     template <typename T>
     void Vector<T, 2>::Set(T s)
     {
         x = s;
         y = s;
     }

     template <typename T>
     void Vector<T, 2>::Set(T newX, T newY)
     {
         x = newX;
         y = newY;
     }

     template <typename T>
     template <typename U>
     void Vector<T, 2>::Set(const std::initializer_list<U>& list)
     {
         assert(list.size() >= 2);

         auto inputElem = list.begin();
         x = static_cast<T>(*inputElem);
         y = static_cast<T>(*(++inputElem));
     }

     template <typename T>
     void Vector<T, 2>::Set(const Vector& v)
     {
         x = v.x;
         y = v.y;
     }

     template <typename T>
     void Vector<T, 2>::SetZero()
     {
         x = 0;
         y = 0;
     }

     template <typename T>
     void Vector<T, 2>::Normalize()
     {
         T length = Length();
         x /= length;
         y /= length;
     }

     template <typename T>
     Vector<T, 2> Vector<T, 2>::Add(T v) const
     {
         return Vector(x + v, y + v);
     }

     template <typename T>
     Vector<T, 2> Vector<T, 2>::Add(const Vector& v) const
     {
         return Vector(x + v.x, y + v.y);
     }


     template <typename T>
     Vector<T, 2> Vector<T, 2>::Sub(T v) const
     {
         return Vector(x - v, y - v);
     }

     template <typename T>
     Vector<T, 2> Vector<T, 2>::Sub(const Vector& v) const
     {
         return Vector(x - v.x, y - v.y);
     }

     template <typename T>
     Vector<T, 2> Vector<T, 2>::Mul(T v) const
     {
         return Vector(x * v, y * v);
     }

     template <typename T>
     Vector<T, 2> Vector<T, 2>::Mul(const Vector& v) const
     {
         return Vector(x * v.x, y * v.y);
     }

     template <typename T>
     Vector<T, 2> Vector<T, 2>::Div(T v) const
     {
         return Vector(x / v, y / v);
     }

     template <typename T>
     Vector<T, 2> Vector<T, 2>::Div(const Vector& v) const
     {
         return Vector(x / v.x, y / v.y);
     }

     template <typename T>
     T Vector<T, 2>::Dot(const Vector& v) const
     {
         return x * v.x + y * v.y;
     }

     template <typename T>
     T Vector<T, 2>::Cross(const Vector& v) const
     {
         return x * v.y - v.x * y;
     }

     template <typename T>
     Vector<T, 2> Vector<T, 2>::RSub(T v) const
     {
         return Vector(v - x, v - y);
     }

     template <typename T>
     Vector<T, 2> Vector<T, 2>::RSub(const Vector& v) const
     {
         return Vector(v.x - x, v.y - y);
     }

     template <typename T>
     Vector<T, 2> Vector<T, 2>::RDiv(T v) const
     {
         return Vector(v / x, v / y);
     }

     template <typename T>
     Vector<T, 2> Vector<T, 2>::RDiv(const Vector& v) const
     {
         return Vector(v.x / x, v.y / y);
     }

     template <typename T>
     T Vector<T, 2>::RCross(const Vector& v) const
     {
         return v.x * y - x * v.y;
     }

     template <typename T>
     void Vector<T, 2>::IAdd(T v)
     {
         x += v;
         y += v;
     }

     template <typename T>
     void Vector<T, 2>::IAdd(const Vector& v)
     {
         x += v.x;
         y += v.y;
     }

     template <typename T>
     void Vector<T, 2>::ISub(T v)
     {
         x -= v;
         y -= v;
     }

     template <typename T>
     void Vector<T, 2>::ISub(const Vector& v)
     {
         x -= v.x;
         y -= v.y;
     }

     template <typename T>
     void Vector<T, 2>::IMul(T v)
     {
         x *= v;
         y *= v;
     }

     template <typename T>
     void Vector<T, 2>::IMul(const Vector& v)
     {
         x *= v.x;
         y *= v.y;
     }

     template <typename T>
     void Vector<T, 2>::IDiv(T v)
     {
         x /= v;
         y /= v;
     }

     template <typename T>
     void Vector<T, 2>::IDiv(const Vector& v)
     {
         x /= v.x;
         y /= v.y;
     }

     template <typename T>
     const T& Vector<T, 2>::At(size_t i) const
     {
         assert(i < 2);
         return (&x)[i];
     }

     template <typename T>
     T& Vector<T, 2>::At(size_t i)
     {
         assert(i < 2);
         return (&x)[i];
     }

     template <typename T>
     T Vector<T, 2>::Sum() const
     {
         return x + y;
     }

     template <typename T>
     T Vector<T, 2>::Avg() const
     {
         return (x + y) / 2;
     }

     template <typename T>
     T Vector<T, 2>::Min() const
     {
         return std::min(x, y);
     }

     template <typename T>
     T Vector<T, 2>::Max() const
     {
         return std::max(x, y);
     }

     template <typename T>
     T Vector<T, 2>::AbsMin() const
     {
         return CubbyFlow::AbsMin(x, y);
     }

     template <typename T>
     T Vector<T, 2>::AbsMax() const
     {
         return CubbyFlow::AbsMax(x, y);
     }

     template <typename T>
     size_t Vector<T, 2>::DominantAxis() const
     {
         return (std::fabs(x) > std::fabs(y)) ? 0 : 1;
     }

     template <typename T>
     size_t Vector<T, 2>::SubdominantAxis() const
     {
         return (std::fabs(x) < std::fabs(y)) ? 0 : 1;
     }

     template <typename T>
     Vector<T, 2> Vector<T, 2>::Normalized() const
     {
         return Vector(x / Length(), y / Length());
     }

     template <typename T>
     T Vector<T, 2>::Length() const
     {
         return std::sqrt(x * x + y * y);
     }

     template <typename T>
     T Vector<T, 2>::LengthSquared() const
     {
         return x * x + y * y;
     }

     template <typename T>
     T Vector<T, 2>::DistanceTo(const Vector<T, 2>& other) const
     {
         return Sub(other).Length();
     }

     template <typename T>
     T Vector<T, 2>::DistanceSquaredTo(const Vector<T, 2>& other) const
     {
         return Sub(other).LengthSquared();
     }

     template <typename T>
     Vector<T, 2> Vector<T, 2>::Reflected(const Vector<T, 2>& normal) const
     {
         // this - 2(this.n)n
         return Sub(normal.Mul(2 * Dot(normal)));
     }

     template <typename T>
     Vector<T, 2> Vector<T, 2>::Projected(const Vector<T, 2>& normal) const
     {
         // this - (this.n)n
         return Sub(normal.Mul(Dot(normal)));
     }

     template <typename T>
     Vector<T, 2> Vector<T, 2>::Tangential() const
     {
         // Rotate 90 degrees
         return Vector<T, 2>(-y, x);
     }

     template <typename T>
     template <typename U>
     Vector<U, 2> Vector<T, 2>::CastTo() const
     {
         return Vector<U, 2>(static_cast<U>(x), static_cast<U>(y));
     }

     template <typename T>
     bool Vector<T, 2>::IsEqual(const Vector& other) const
     {
         return (x == other.x && y == other.y);
     }

     template <typename T>
     bool Vector<T, 2>::IsSimilar(const Vector& other, T epsilon) const
     {
         return (std::fabs(x - other.x) < epsilon) && (std::fabs(y - other.y) < epsilon);
     }

     template <typename T>
     T& Vector<T, 2>::operator[](size_t i)
     {
         assert(i < 2);
         return (&x)[i];
     }

     template <typename T>
     const T& Vector<T, 2>::operator[](size_t i) const
     {
         return At(i);
     }

     template <typename T>
     template <typename U>
     Vector<T, 2>& Vector<T, 2>::operator=(const std::initializer_list<U>& list)
     {
         Set(list);
         return (*this);
     }

     template <typename T>
     Vector<T, 2>& Vector<T, 2>::operator=(const Vector& v)
     {
         Set(v);
         return (*this);
     }

     template <typename T>
     Vector<T, 2>& Vector<T, 2>::operator+=(T v)
     {
         IAdd(v);
         return (*this);
     }

     template <typename T>
     Vector<T, 2>& Vector<T, 2>::operator+=(const Vector& v)
     {
         IAdd(v);
         return (*this);
     }

     template <typename T>
     Vector<T, 2>& Vector<T, 2>::operator-=(T v)
     {
         ISub(v);
         return (*this);
     }

     template <typename T>
     Vector<T, 2>& Vector<T, 2>::operator-=(const Vector& v)
     {
         ISub(v);
         return (*this);
     }

     template <typename T>
     Vector<T, 2>& Vector<T, 2>::operator*=(T v)
     {
         IMul(v);
         return (*this);
     }

     template <typename T>
     Vector<T, 2>& Vector<T, 2>::operator*=(const Vector& v)
     {
         IMul(v);
         return (*this);
     }

     template <typename T>
     Vector<T, 2>& Vector<T, 2>::operator/=(T v)
     {
         IDiv(v);
         return (*this);
     }

     template <typename T>
     Vector<T, 2>& Vector<T, 2>::operator/=(const Vector& v)
     {
         IDiv(v);
         return (*this);
     }

     template <typename T>
     bool Vector<T, 2>::operator==(const Vector& v) const
     {
         return IsEqual(v);
     }

     template <typename T>
     bool Vector<T, 2>::operator!=(const Vector& v) const
     {
         return !IsEqual(v);
     }

     template <typename T>
     Vector<T, 2> operator+(const Vector<T, 2>& a)
     {
         return a;
     }

     template <typename T>
     Vector<T, 2> operator-(const Vector<T, 2>& a)
     {
         return Vector<T, 2>(-a.x, -a.y);
     }

     template <typename T>
     Vector<T, 2> operator+(const Vector<T, 2>& a, T b)
     {
         return a.Add(b);
     }

     template <typename T>
     Vector<T, 2> operator+(T a, const Vector<T, 2>& b)
     {
         return b.Add(a);
     }

     template <typename T>
     Vector<T, 2> operator+(const Vector<T, 2>& a, const Vector<T, 2>& b)
     {
         return a.Add(b);
     }

     template <typename T>
     Vector<T, 2> operator-(const Vector<T, 2>& a, T b)
     {
         return a.Sub(b);
     }


     template <typename T>
     Vector<T, 2> operator-(T a, const Vector<T, 2>& b)
     {
         return b.RSub(a);
     }

     template <typename T>
     Vector<T, 2> operator-(const Vector<T, 2>& a, const Vector<T, 2>& b)
     {
         return a.Sub(b);
     }

     template <typename T>
     Vector<T, 2> operator*(const Vector<T, 2>& a, T b)
     {
         return a.Mul(b);
     }

     template <typename T>
     Vector<T, 2> operator*(T a, const Vector<T, 2>& b)
     {
         return b.Mul(a);
     }

     template <typename T>
     Vector<T, 2> operator*(const Vector<T, 2>& a, const Vector<T, 2>& b)
     {
         return a.Mul(b);
     }

     template <typename T>
     Vector<T, 2> operator/(const Vector<T, 2>& a, T b)
     {
         return a.Div(b);
     }

     template <typename T>
     Vector<T, 2> operator/(T a, const Vector<T, 2>& b)
     {
         return b.RDiv(a);
     }

     template <typename T>
     Vector<T, 2> operator/(const Vector<T, 2>& a, const Vector<T, 2>& b)
     {
         return a.Div(b);
     }

     template <typename T>
     Vector<T, 2> Min(const Vector<T, 2>& a, const Vector<T, 2>& b)
     {
         return Vector<T, 2>(std::min(a.x, b.x), std::min(a.y, b.y));
     }

     template <typename T>
     Vector<T, 2> Max(const Vector<T, 2>& a, const Vector<T, 2>& b)
     {
         return Vector<T, 2>(std::max(a.x, b.x), std::max(a.y, b.y));
     }

     template <typename T>
     Vector<T, 2> Clamp(const Vector<T, 2>& v, const Vector<T, 2>& low, const Vector<T, 2>& high)
     {
         return Vector<T, 2>(Clamp(v.x, low.x, high.x), Clamp(v.y, low.y, high.y));
     }

     template <typename T>
     Vector<T, 2> Ceil(const Vector<T, 2>& a)
     {
         return Vector<T, 2>(std::ceil(a.x), std::ceil(a.y));
     }

     template <typename T>
     Vector<T, 2> Floor(const Vector<T, 2>& a)
     {
         return Vector<T, 2>(std::floor(a.x), std::floor(a.y));
     }

     template <typename T>
     Vector<T, 2> MonotonicCatmullRom(
         const Vector<T, 2>& v0,
         const Vector<T, 2>& v1,
         const Vector<T, 2>& v2,
         const Vector<T, 2>& v3,
         T f)
     {
         static const T two = static_cast<T>(2);
         static const T three = static_cast<T>(3);

         Vector<T, 2> d1 = (v2 - v0) / two;
         Vector<T, 2> d2 = (v3 - v1) / two;
         Vector<T, 2> D1 = v2 - v1;

         if (std::fabs(D1.x) < std::numeric_limits<T>::epsilon() ||
             Sign(D1.x) != Sign(d1.x) ||
             Sign(D1.x) != Sign(d2.x))
         {
             d1.x = d2.x = 0;
         }

         if (std::fabs(D1.y) < std::numeric_limits<T>::epsilon() ||
             Sign(D1.y) != Sign(d1.y) ||
             Sign(D1.y) != Sign(d2.y))
         {
             d1.y = d2.y = 0;
         }

         Vector<T, 2> a3 = d1 + d2 - two * D1;
         Vector<T, 2> a2 = three * D1 - two * d1 - d2;
         Vector<T, 2> a1 = d1;
         Vector<T, 2> a0 = v1;

         return a3 * Cubic(f) + a2 * Square(f) + a1 * f + a0;
     }
 }

 #endif
CubbyFlow::Vector::Max
T Max() const
Returns the maximum element.
Definition: Vector-Impl.h:208

CubbyFlow::Vector< T, 2 >::x
T x
X (or the first) component of the vector.
Definition: Vector2.h:29

MathUtils.h

CubbyFlow::AbsMin
T AbsMin(T x, T y)
Returns the absolute minimum value among the two inputs.
Definition: MathUtils-Impl.h:39

CubbyFlow::Vector::RDiv
VectorScalarRDiv< T, Vector > RDiv(const T &s) const
Computes (s, s, ... , s) / this.
Definition: Vector-Impl.h:440

CubbyFlow::Vector::DominantAxis
size_t DominantAxis() const
Returns the index of the dominant axis.
Definition: Vector-Impl.h:247

CubbyFlow::Vector::DistanceTo
T DistanceTo(const E &other) const
Returns the distance to the other vector.
Definition: Vector-Impl.h:289

CubbyFlow::Ceil
Point< T, 2 > Ceil(const Point< T, 2 > &a)
Returns element-wise ceiled point.
Definition: Point2-Impl.h:492

CubbyFlow::Vector::operator[]
const T & operator[](size_t i) const
Returns the const reference to the i -th element.
Definition: Vector-Impl.h:519

CubbyFlow::operator+
Matrix< T, 2, 2 > operator+(const Matrix< T, 2, 2 > &a, const Matrix< T, 2, 2 > &b)
Returns a + b (element-size).
Definition: Matrix2x2-Impl.h:660

CubbyFlow::Vector::SubdominantAxis
size_t SubdominantAxis() const
Returns the index of the subdominant axis.
Definition: Vector-Impl.h:258

CubbyFlow::Vector::CastTo
VectorTypeCast< U, Vector< T, N >, T > CastTo() const
Returns a vector with different value type.
Definition: Vector-Impl.h:313

CubbyFlow::Square
T Square(T x)
Returns the square of x.
Definition: MathUtils-Impl.h:111

CubbyFlow::Vector< T, 2 >::Sub
Vector Sub(T v) const
Computes this - (v, v).
Definition: Vector2-Impl.h:88

CubbyFlow::Vector::operator=
Vector & operator=(const std::initializer_list< U > &list)
Set vector instance with initializer list.

CubbyFlow::Vector::Sub
VectorSub< T, Vector, E > Sub(const E &v) const
Computes this - v.

CubbyFlow::Vector
Generic statically-sized N-D vector class.
Definition: Vector.h:33

CubbyFlow::Vector::Vector
Vector()
Constructs a vector with zeros.
Definition: Vector-Impl.h:17

CubbyFlow::Vector< T, 2 >::Mul
Vector Mul(T v) const
Computes this * (v, v).
Definition: Vector2-Impl.h:100

CubbyFlow::Vector::IsEqual
bool IsEqual(const E &other) const
Returns true if other is the same as this vector.
Definition: Vector-Impl.h:320

CubbyFlow::Vector::LengthSquared
T LengthSquared() const
Returns the squared length of the vector.
Definition: Vector-Impl.h:282

CubbyFlow::Vector::At
T At(size_t i) const
Returns const reference to the i -th element of the vector.
Definition: Vector-Impl.h:164

CubbyFlow::Floor
Point< T, 2 > Floor(const Point< T, 2 > &a)
Returns element-wise floored point.
Definition: Point2-Impl.h:498

CubbyFlow::Vector::Div
VectorDiv< T, Vector, E > Div(const E &v) const
Computes this / v.

CubbyFlow::Vector< T, 2 >::Div
Vector Div(T v) const
Computes this / (v, v).
Definition: Vector2-Impl.h:112

CubbyFlow::Vector::operator==
bool operator==(const E &v) const
Returns true if other is the same as this vector.
Definition: Vector-Impl.h:608

CubbyFlow::operator/
Matrix< T, 2, 2 > operator/(const Matrix< T, 2, 2 > &a, T b)
Definition: Matrix2x2-Impl.h:720

CubbyFlow
Definition: pybind11Utils.h:24

CubbyFlow::Vector::IAdd
void IAdd(const T &s)
Computes this += (s, s, ... , s).
Definition: Vector-Impl.h:453

CubbyFlow::Vector::Min
T Min() const
Returns the minimum element.
Definition: Vector-Impl.h:195

CubbyFlow::Clamp
T Clamp(T val, T low, T high)
Returns the clamped value.
Definition: MathUtils-Impl.h:123

CubbyFlow::Vector::operator-=
Vector & operator-=(const T &s)
Computes this -= (s, s, ... , s)
Definition: Vector-Impl.h:562

CubbyFlow::Vector::Set
void Set(const T &s)
Sets all elements to s.
Definition: Vector-Impl.h:55

CubbyFlow::Vector::Avg
T Avg() const
Returns the average of all the elements.
Definition: Vector-Impl.h:189

CubbyFlow::Vector::Dot
T Dot(const E &v) const
Computes dot product.
Definition: Vector-Impl.h:412

CubbyFlow::Vector::IMul
void IMul(const T &s)
Computes this *= (s, s, ... , s).
Definition: Vector-Impl.h:479

CubbyFlow::Vector< T, 2 >::RSub
Vector RSub(T v) const
Computes (v, v) - this.
Definition: Vector2-Impl.h:136

CubbyFlow::Vector< T, 2 >::RDiv
Vector RDiv(T v) const
Computes (v, v) / this.
Definition: Vector2-Impl.h:148

CubbyFlow::Vector::Normalized
VectorScalarDiv< T, Vector > Normalized() const
Returns normalized vector.
Definition: Vector-Impl.h:269

CubbyFlow::operator-
Matrix< T, 2, 2 > operator-(const Matrix< T, 2, 2 > &a)
Returns a matrix with opposite sign.
Definition: Matrix2x2-Impl.h:654

CubbyFlow::Vector< T, 2 >::y
T y
Y (or the second) component of the vector.
Definition: Vector2.h:35

CubbyFlow::Vector::operator*=
Vector & operator*=(const T &s)
Computes this *= (s, s, ... , s)
Definition: Vector-Impl.h:577

CubbyFlow::Max
Point< T, 2 > Max(const Point< T, 2 > &a, const Point< T, 2 > &b)
Returns element-wise max point: (max(a.x, b.x), max(a.y, b.y)).
Definition: Point2-Impl.h:480

CubbyFlow::Vector::operator/=
Vector & operator/=(const T &s)
Computes this /= (s, s, ... , s)
Definition: Vector-Impl.h:592

CubbyFlow::Vector::operator+=
Vector & operator+=(const T &s)
Computes this += (s, s, ... , s)
Definition: Vector-Impl.h:547

CubbyFlow::Vector::Mul
VectorMul< T, Vector, E > Mul(const E &v) const
Computes this * v.

CubbyFlow::Vector::AbsMax
T AbsMax() const
Returns the absolute maximum element.
Definition: Vector-Impl.h:234

CubbyFlow::Vector::DistanceSquaredTo
T DistanceSquaredTo(const E &other) const
Returns the squared distance to the other vector.
Definition: Vector-Impl.h:296

CubbyFlow::Vector::Sum
T Sum() const
Returns the sum of all the elements.
Definition: Vector-Impl.h:176

CubbyFlow::Cubic
T Cubic(T x)
Returns the cubic of x.
Definition: MathUtils-Impl.h:117

CubbyFlow::Vector< T, 2 >
2-D vector class.
Definition: Vector2.h:26

CubbyFlow::Vector::IsSimilar
bool IsSimilar(const E &other, T epsilon=std::numeric_limits< T >::epsilon()) const
Returns true if other is similar to this vector.
Definition: Vector-Impl.h:340

CubbyFlow::Vector::AbsMin
T AbsMin() const
Returns the absolute minimum element.
Definition: Vector-Impl.h:221

CubbyFlow::operator*
Vector< T, 3 > operator*(const Quaternion< T > &q, const Vector< T, 3 > &v)
Returns quaternion q * vector v.
Definition: Quaternion-Impl.h:481

CubbyFlow::MonotonicCatmullRom
T MonotonicCatmullRom(const T &f0, const T &f1, const T &f2, const T &f3, T f)
Computes monotonic Catmull-Rom interpolation.
Definition: MathUtils-Impl.h:228

CubbyFlow::AbsMax
T AbsMax(T x, T y)
Returns the absolute maximum value among the two inputs.
Definition: MathUtils-Impl.h:45

CubbyFlow::Vector::ISub
void ISub(const T &s)
Computes this -= (s, s, ... , s).
Definition: Vector-Impl.h:466

CubbyFlow::Sign
T Sign(T x)
Returns the sign of the value.
Definition: MathUtils-Impl.h:26

CubbyFlow::Vector::Add
VectorAdd< T, Vector, E > Add(const E &v) const
Computes this + v.

CubbyFlow::Vector::operator!=
bool operator!=(const E &v) const
Returns true if other is the not same as this vector.
Definition: Vector-Impl.h:615

CubbyFlow::Vector::SetZero
void SetZero()
Sets all elements to zero.
Definition: Vector-Impl.h:98

CubbyFlow::Min
Point< T, 2 > Min(const Point< T, 2 > &a, const Point< T, 2 > &b)
Returns element-wise min point: (min(a.x, b.x), min(a.y, b.y)).
Definition: Point2-Impl.h:474

CubbyFlow::Vector::RSub
VectorScalarRSub< T, Vector > RSub(const T &s) const
Computes (s, s, ... , s) - this.
Definition: Vector-Impl.h:427

CubbyFlow::Vector< T, 2 >::Add
Vector Add(T v) const
Computes this + (v, v).
Definition: Vector2-Impl.h:75

CubbyFlow::Vector::Length
T Length() const
Returns the length of the vector.
Definition: Vector-Impl.h:276

CubbyFlow::Vector::Normalize
void Normalize()
Normalizes this vector.
Definition: Vector-Impl.h:104

CubbyFlow::Vector::IDiv
void IDiv(const T &s)
Computes this /= (s, s, ... , s).
Definition: Vector-Impl.h:492