Hermes
Loading...
Searching...
No Matches
vector.h
Go to the documentation of this file.
1
31
32#ifndef HERMES_GEOMETRY_VECTOR_H
33#define HERMES_GEOMETRY_VECTOR_H
34
35#include <hermes/numeric/numeric.h>
36#include <hermes/common/debug.h>
37#include <hermes/common/index.h>
38#include <hermes/numeric/interval.h>
39
40#include <cstring>
41#include <initializer_list>
42#include <vector>
43
44namespace hermes {
45
48template<typename T> class Point2;
49// *********************************************************************************************************************
50// Vector2
51// *********************************************************************************************************************
54template<typename T> class Vector2 : public MathElement<T, 2u> {
55 static_assert(std::is_same<T, f32>::value || std::is_same<T, f64>::value ||
56 std::is_same<T, Interval<f32>>::value || std::is_same<T, Interval<f64>>::value,
57 "Vector2 must hold an float type!");
58
59public:
60 // *******************************************************************************************************************
61 // CONSTRUCTORS
62 // *******************************************************************************************************************
64 HERMES_DEVICE_CALLABLE Vector2() : x{0}, y{0} {};
68 HERMES_DEVICE_CALLABLE Vector2(T _x, T _y) : x(_x), y(_y) {}
71 HERMES_DEVICE_CALLABLE explicit Vector2(const Point2<T> &p) : x(p.x), y(p.y) {}
74 HERMES_DEVICE_CALLABLE explicit Vector2(T f) { x = y = f; }
77 HERMES_DEVICE_CALLABLE explicit Vector2(T *f) {
78 x = f[0];
79 y = f[1];
80 }
81 // *******************************************************************************************************************
82 // OPERATORS
83 // *******************************************************************************************************************
84 // access
89 HERMES_DEVICE_CALLABLE T operator[](size_t i) const { return (&x)[i]; }
94 HERMES_DEVICE_CALLABLE T &operator[](size_t i) { return (&x)[i]; }
95 // arithmetic
96#define ARITHMETIC_OP(OP) \
97 HERMES_DEVICE_CALLABLE Vector2 &operator OP##= (const Vector2 &v) { \
98 x OP##= v.x; y OP##= v.y; return *this; } \
99 HERMES_DEVICE_CALLABLE Vector2 &operator OP##= (real_t f) { \
100 x OP##= f; y OP##= f; return *this; } \
101 HERMES_DEVICE_CALLABLE Vector2 operator OP (const Vector2<T> &b) const { \
102 return {x OP b.x, y OP b.y}; } \
103 HERMES_DEVICE_CALLABLE Vector2 operator OP (real_t f) const { \
104 return {x OP f, y OP f}; }
105 ARITHMETIC_OP(+)
106 ARITHMETIC_OP(-)
107 ARITHMETIC_OP(*)
108 ARITHMETIC_OP(/)
109#undef ARITHMETIC_OP
110 HERMES_DEVICE_CALLABLE Vector2 operator-() const { return Vector2(-x, -y); }
111 // relational
112#define RELATIONAL_OP(OP, CO) \
113 HERMES_DEVICE_CALLABLE bool operator OP (const Vector2 &b) const { \
114 return x OP b.x CO y OP b.y; }
115 RELATIONAL_OP(<, &&)
116 RELATIONAL_OP(>, &&)
117 RELATIONAL_OP(<=, &&)
118 RELATIONAL_OP(>=, &&)
119 RELATIONAL_OP(!=, ||)
120#undef RELATIONAL_OP
121 HERMES_DEVICE_CALLABLE bool operator==(const Vector2<T> &b) const {
122 return Check::is_equal(x, b.x) && Check::is_equal(y, b.y);
123 }
124 // *******************************************************************************************************************
125 // METHODS
126 // *******************************************************************************************************************
129 HERMES_DEVICE_CALLABLE T length2() const { return x * x + y * y; }
132 HERMES_DEVICE_CALLABLE T length() const { return sqrtf(length2()); }
135 HERMES_DEVICE_CALLABLE Vector2 right() const { return Vector2(y, -x); }
138 HERMES_DEVICE_CALLABLE Vector2 left() const { return Vector2(-y, x); }
139 // swizzle
142 Vector2 xy() const { return {x, y}; }
145 Vector2 yx() const { return {y, x}; }
148 Vector2 xx() const { return {x, x}; }
151 Vector2 yy() const { return {y, y}; }
152 // *******************************************************************************************************************
153 // PUBLIC FIELDS
154 // *******************************************************************************************************************
155 T x = T(0.0);
156 T y = T(0.0);
157};
158
159template<typename T> class Point3;
160
161// *********************************************************************************************************************
162// Vector3
163// *********************************************************************************************************************
166template<typename T> class Vector3 : public MathElement<T, 3u> {
167 static_assert(std::is_same<T, f32>::value || std::is_same<T, f64>::value ||
168 std::is_same<T, Interval<f32>>::value || std::is_same<T, Interval<f64>>::value,
169 "Vector3 must hold an float type!");
170
171public:
172 // *******************************************************************************************************************
173 // CONSTRUCTORS
174 // *******************************************************************************************************************
176 HERMES_DEVICE_CALLABLE Vector3() : x{0}, y{0}, z{0} {}
179 HERMES_DEVICE_CALLABLE explicit Vector3(T _f) : x(_f), y(_f), z(_f) {}
184 HERMES_DEVICE_CALLABLE Vector3(T _x, T _y, T _z) : x(_x), y(_y), z(_z) {}
187 HERMES_DEVICE_CALLABLE explicit Vector3(const T *v) {
188 x = v[0];
189 y = v[1];
190 z = v[2];
191 }
192 // conversion
195 HERMES_DEVICE_CALLABLE explicit Vector3(const Point3<T> &p) : x(p.x), y(p.y), z(p.z) {}
200 template<typename S, typename C = T>
201 HERMES_DEVICE_CALLABLE explicit Vector3(const Vector3<Interval<S>> &vi,
202 typename std::enable_if_t<
203 !std::is_same_v<C, Interval<f32>>
204 && !std::is_same_v<C, Interval<f64>>> * = nullptr) :
205 x(vi.x), y(vi.y), z(vi.z) {}
206 // *******************************************************************************************************************
207 // OPERATORS
208 // *******************************************************************************************************************
209 // assignment
213 HERMES_DEVICE_CALLABLE Vector3 &operator=(const T &v) {
214 x = y = z = v;
215 return *this;
216 }
217 // arithmetic
218#define ARITHMETIC_OP(OP) \
219 HERMES_DEVICE_CALLABLE Vector3 &operator OP##= (const Vector3 &v) { \
220 x OP##= v.x; y OP##= v.y; z OP##= v.z; return *this; } \
221 HERMES_DEVICE_CALLABLE Vector3 &operator OP##= (real_t f) { \
222 x OP##= f; y OP##= f; z OP##= f; return *this; } \
223 HERMES_DEVICE_CALLABLE Vector3 operator OP (const Vector3<T> &b) const { \
224 return {x OP b.x, y OP b.y, z OP b.z}; } \
225 HERMES_DEVICE_CALLABLE Vector3 operator OP (T f) const { \
226 return {x OP f, y OP f, z OP f}; }
227 ARITHMETIC_OP(+)
228 ARITHMETIC_OP(-)
229 ARITHMETIC_OP(*)
230#undef ARITHMETIC_OP
231 HERMES_DEVICE_CALLABLE Vector3<T> &operator/=(T f) {
232 HERMES_CHECK_EXP(Check::is_zero(f))
233 T inv = 1.f / f;
234 x *= inv;
235 y *= inv;
236 z *= inv;
237 return *this;
238 }
239 HERMES_DEVICE_CALLABLE Vector3<T> &operator/=(const Vector3<T> &v) {
240 x /= v.x;
241 y /= v.y;
242 z /= v.z;
243 return *this;
244 }
245 HERMES_DEVICE_CALLABLE Vector3<T> operator/(const T &f) const {
246 T inv = 1.f / f;
247 return Vector3<T>(x * inv, y * inv, z * inv);
248 }
249 HERMES_DEVICE_CALLABLE Vector3<T> operator-() const { return Vector3(-x, -y, -z); }
250 // relational
251 HERMES_DEVICE_CALLABLE bool operator==(const Vector3<T> &b) const {
252 return Check::is_equal(x, b.x) && Check::is_equal(y, b.y) &&
253 Check::is_equal(z, b.z);
254 }
255 HERMES_DEVICE_CALLABLE bool operator<(const Vector3<T> &b) const {
256 if (x < b.x)
257 return true;
258 if (y < b.y)
259 return true;
260 return z < b.z;
261 }
262 HERMES_DEVICE_CALLABLE bool operator>(const Vector3<T> &b) const {
263 if (x > b.x)
264 return true;
265 if (y > b.y)
266 return true;
267 return z > b.z;
268 }
269 HERMES_DEVICE_CALLABLE bool operator>=(const Vector3<T> &b) const {
270 return x >= b.x && y >= b.y && z >= b.z;
271 }
272 HERMES_DEVICE_CALLABLE bool operator<=(const Vector3<T> &b) const {
273 return x <= b.x && y <= b.y && z <= b.z;
274 }
275 // *******************************************************************************************************************
276 // ACCESS
277 // *******************************************************************************************************************
282 HERMES_DEVICE_CALLABLE T operator[](int i) const { return (&x)[i]; }
287 HERMES_DEVICE_CALLABLE T &operator[](int i) { return (&x)[i]; }
292 HERMES_DEVICE_CALLABLE Vector2<T> xy(int i = 0, int j = 1) const {
293 return Vector2<T>((&x)[i], (&x)[j]);
294 }
295 // *******************************************************************************************************************
296 // METRICS
297 // *******************************************************************************************************************
302 HERMES_DEVICE_CALLABLE T mLength() const { return std::abs(x) + std::abs(y) + std::abs(z); }
307 template<typename C = T>
308 HERMES_DEVICE_CALLABLE T length(typename std::enable_if_t<!std::is_same_v<C, Interval<f32>>
309 && !std::is_same_v<C,
310 Interval<f64>>> * = nullptr) const {
311 return std::sqrt(length2());
312 }
316 template<typename C = T>
317 HERMES_DEVICE_CALLABLE T length(typename std::enable_if_t<std::is_same_v<C, Interval<f32>>
318 || std::is_same_v<C,
319 Interval<f64>>> * = nullptr) const {
320 return length2().sqrt();
321 }
326 HERMES_DEVICE_CALLABLE T length2() const { return x * x + y * y + z * z; }
331 HERMES_DEVICE_CALLABLE T maxAbs() const {
332 if (std::abs(x) > std::abs(y) && std::abs(x) > std::abs(z))
333 return x;
334 if (std::abs(y) > std::abs(x) && std::abs(y) > std::abs(z))
335 return y;
336 return z;
337 }
341 HERMES_DEVICE_CALLABLE T max() const {
342 if (x > y && x > z)
343 return x;
344 if (y > x && y > z)
345 return y;
346 return z;
347 }
351 [[nodiscard]] HERMES_DEVICE_CALLABLE int maxDimension() const {
352 if (x > y && x > z)
353 return 0;
354 if (y > x && y > z)
355 return 1;
356 return 2;
357 }
361 [[nodiscard]] HERMES_DEVICE_CALLABLE int maxAbsDimension() const {
362 if (std::abs(x) > std::abs(y) && std::abs(x) > std::abs(z))
363 return 0;
364 if (std::abs(y) > std::abs(x) && std::abs(y) > std::abs(z))
365 return 1;
366 return 2;
367 }
368 // *******************************************************************************************************************
369 // OPERATIONS
370 // *******************************************************************************************************************
374 HERMES_DEVICE_CALLABLE void normalize() {
375 auto l = length();
376 if (l != 0.f) {
377 x /= l;
378 y /= l;
379 z /= l;
380 }
381 }
386 HERMES_DEVICE_CALLABLE Vector3 normalized() const {
387 auto l = length();
388 return (*this) / l;
389 }
394 HERMES_DEVICE_CALLABLE Vector3 projectOnto(const Vector3 &b) {
395 return (dot(b, *this) / b.length2()) * b;
396 }
401 HERMES_DEVICE_CALLABLE Vector3 rejectOn(const Vector3 b) {
402 return *this - (dot(b, *this) / b.length2()) * b;
403 }
404 // *******************************************************************************************************************
405 // DEBUG
406 // *******************************************************************************************************************
409 HERMES_DEVICE_CALLABLE [[nodiscard]] bool hasNaNs() const {
410 return Check::is_nan(x) || Check::is_nan(y) || Check::is_nan(z);
411 }
412 // *******************************************************************************************************************
413 // PUBLIC FIELDS
414 // *******************************************************************************************************************
415 T x = T(0.0);
416 T y = T(0.0);
417 T z = T(0.0);
418};
419
420// *********************************************************************************************************************
421// Vector4
422// *********************************************************************************************************************
425template<typename T> class Vector4 : public MathElement<T, 4> {
426public:
427 // *******************************************************************************************************************
428 // CONSTRUCTORS
429 // *******************************************************************************************************************
431 HERMES_DEVICE_CALLABLE Vector4() : x{0}, y{0}, z{0}, w{0} {}
437 HERMES_DEVICE_CALLABLE Vector4(T _x, T _y, T _z, T _w) : x(_x), y(_y), z(_z), w(_w) {}
438 // *******************************************************************************************************************
439 // OPERATORS
440 // *******************************************************************************************************************
441 // arithmetic
442 HERMES_DEVICE_CALLABLE Vector4<T> &operator+=(const Vector4<T> &v) {
443 x += v.x;
444 y += v.y;
445 z += v.z;
446 w += v.w;
447 return *this;
448 }
449 HERMES_DEVICE_CALLABLE Vector4<T> &operator-=(const Vector4<T> &v) {
450 x -= v.x;
451 y -= v.y;
452 z -= v.z;
453 w -= v.w;
454 return *this;
455 }
456 HERMES_DEVICE_CALLABLE Vector4<T> &operator*=(T f) {
457 x *= f;
458 y *= f;
459 z *= f;
460 w *= f;
461 return *this;
462 }
463 HERMES_DEVICE_CALLABLE Vector4<T> &operator/=(T f) {
464 T inv = 1.f / f;
465 x *= inv;
466 y *= inv;
467 z *= inv;
468 w *= inv;
469 return *this;
470 }
471 HERMES_DEVICE_CALLABLE Vector4<T> operator-() const { return Vector4(-x, -y, -z, -w); }
472 HERMES_DEVICE_CALLABLE Vector4<T> operator+(const Vector4<T> &b) {
473 return Vector4<T>(x + b.x, y + b.y, z + b.z, w + b.w);
474 }
475 HERMES_DEVICE_CALLABLE Vector4<T> operator-(const Vector4<T> &b) {
476 return Vector4<T>(x - b.x, y - b.y, z - b.z, w - b.w);
477 }
478 HERMES_DEVICE_CALLABLE Vector4<T> operator*(T f) {
479 return Vector4<T>(x * f, y * f, z * f, w * f);
480 }
481 HERMES_DEVICE_CALLABLE Vector4<T> operator/(T f) {
482 T inv = 1.f / f;
483 return Vector4<T>(x * inv, y * inv, z * inv, w * inv);
484 }
485 // *******************************************************************************************************************
486 // ACCESS
487 // *******************************************************************************************************************
492 HERMES_DEVICE_CALLABLE T operator[](int i) const { return (&x)[i]; }
497 HERMES_DEVICE_CALLABLE T &operator[](int i) { return (&x)[i]; }
500 HERMES_DEVICE_CALLABLE Vector2<T> xy() { return Vector2<T>(x, y); }
503 HERMES_DEVICE_CALLABLE Vector3<T> xyz() { return Vector3<T>(x, y, z); }
504 // *******************************************************************************************************************
505 // METRICS
506 // *******************************************************************************************************************
509 HERMES_DEVICE_CALLABLE T length2() const { return x * x + y * y + z * z + w * w; }
512 HERMES_DEVICE_CALLABLE T length() const { return sqrtf(length2()); }
513 // *******************************************************************************************************************
514 // PUBLIC FIELDS
515 // *******************************************************************************************************************
516 T x = T(0.0);
517 T y = T(0.0);
518 T z = T(0.0);
519 T w = T(0.0);
520};
521
522// *********************************************************************************************************************
523// EXTERNAL FUNCTIONS
524// *********************************************************************************************************************
525// geometry
531template<typename T>
532HERMES_DEVICE_CALLABLE T dot(const Vector2<T> &a, const Vector2<T> &b) {
533 return a.x * b.x + a.y * b.y;
534}
540template<typename T>
541HERMES_DEVICE_CALLABLE T dot(const Vector3<T> &a, const Vector3<T> &b) {
542 return a.x * b.x + a.y * b.y + a.z * b.z;
543}
549template<typename T>
550HERMES_DEVICE_CALLABLE T cross(const Vector2<T> &a, const Vector2<T> &b) {
551 return a.x * b.y - a.y * b.x;
552}
558template<typename T>
559HERMES_DEVICE_CALLABLE Vector3<T> cross(const Vector3<T> &a, const Vector3<T> &b) {
560 return Vector3<T>((a.y * b.z) - (a.z * b.y), (a.z * b.x) - (a.x * b.z),
561 (a.x * b.y) - (a.y * b.x));
562}
569template<typename T>
570HERMES_DEVICE_CALLABLE T triple(const Vector3<T> &a, const Vector3<T> &b, const Vector3<T> &c) {
571 return dot(a, cross(b, c));
572}
577template<typename T>
578HERMES_DEVICE_CALLABLE Vector2<T> normalize(const Vector2<T> &v) {
579 return v / v.length();
580}
585template<typename T>
586HERMES_DEVICE_CALLABLE Vector3<T> normalize(const Vector3<T> &v) {
587 if (v.length2() == 0.f)
588 return v;
589 return v / v.length();
590}
596template<typename T>
597HERMES_DEVICE_CALLABLE Vector2<T> orthonormal(const Vector2<T> &v, bool first = true) {
598 Vector2<T> n = normalize(v);
599 if (first)
600 return Vector2<T>(-n.y, n.x);
601 return Vector2<T>(n.y, -n.x);
602}
607template<typename T>
608HERMES_DEVICE_CALLABLE Vector2<T> project(const Vector2<T> &a, const Vector2<T> &b) {
609 return (dot(b, a) / b.length2()) * b;
610}
617template<typename T>
618HERMES_DEVICE_CALLABLE Vector3<T> project(const Vector3<T> &a, const Vector3<T> &b) {
619 return (dot(b, a) / b.length2()) * b;
620}
626template<typename T>
627HERMES_DEVICE_CALLABLE Vector3<T> reject(const Vector3<T> &a, const Vector3<T> &b) {
628 return a - (dot(b, a) / b.length2()) * b;
629}
634template<typename T>
635HERMES_DEVICE_CALLABLE void tangential(const Vector3<T> &a, Vector3<T> &b, Vector3<T> &c) {
636 b = hermes::normalize(cross(a, ((std::abs(a.y) > 0.f || std::abs(a.z) > 0.f)
637 ? Vector3<T>(1, 0, 0)
638 : Vector3<T>(0, 1, 1))));
639 c = hermes::normalize(cross(a, b));
640}
641
642
643// arithmetic
644#define DOP2(OP) f OP v.x, f OP v.y
645#define DOP3(OP) f OP v.x, f OP v.y, f OP v.z
646#define MATH_OP(D, OP) \
647template<typename T> \
648HERMES_DEVICE_CALLABLE Vector##D<T> operator OP(T f, const Vector##D<T> &v) { \
649 return Vector##D<T>(DOP##D(OP)); }
650MATH_OP(2, *)
651MATH_OP(2, /)
652MATH_OP(3, *)
653MATH_OP(3, /)
654#undef MATH_OP
655#undef DOP2
656#undef DOP3
657
658#define DOP2(OP) OP(a.x, b.x), OP(a.y, b.y)
659#define DOP3(OP) OP(a.x, b.x), OP(a.y, b.y), OP(a.z, b.z)
660#define MATH_OP(D, NAME, OP) \
661template<typename T> \
662HERMES_DEVICE_CALLABLE Vector##D<T> NAME(const Vector##D<T> &a, const Vector##D<T> &b) { \
663 return Vector##D<T>(DOP##D(OP)); }
664#ifdef HERMES_DEVICE_ENABLED
665MATH_OP(2, min, min)
666MATH_OP(2, max, max)
667MATH_OP(3, min, min)
668MATH_OP(3, max, max)
669#else
670MATH_OP(2, min, std::min)
671MATH_OP(2, max, std::max)
672MATH_OP(3, min, std::min)
673MATH_OP(3, max, std::max)
674#endif
675#undef MATH_OP
676#undef DOP2
677#undef DOP3
678
679// numbers
680#define DOP2(OP) OP(v.x), OP(v.y)
681#define DOP3(OP) OP(v.x), OP(v.y), OP(v.z)
682#define MATH_OP(NAME, OP, D) \
683 template<typename T> \
684 HERMES_DEVICE_CALLABLE Vector##D<T> NAME(const Vector##D<T>& v) { \
685 return Vector##D<T>(DOP##D(OP)); }
686#ifdef HERMES_DEVICE_ENABLED
687MATH_OP(floor, ::floor, 2)
688MATH_OP(ceil, ::ceil, 2)
689MATH_OP(abs, ::abs, 2)
690MATH_OP(cos, ::cos, 2)
691MATH_OP(floor, ::floor, 3)
692MATH_OP(ceil, ::ceil, 3)
693MATH_OP(abs, ::abs, 3)
694MATH_OP(cos, ::cos, 3)
695#else
696MATH_OP(floor, std::floor, 2)
697MATH_OP(ceil, std::ceil, 2)
698MATH_OP(abs, std::abs, 2)
699MATH_OP(cos, std::cos, 2)
700MATH_OP(floor, std::floor, 3)
701MATH_OP(ceil, std::ceil, 3)
702MATH_OP(abs, std::abs, 3)
703MATH_OP(cos, std::cos, 3)
704#endif
705#undef MATH_OP
706#undef DOP2
707#undef DOP3
708// *********************************************************************************************************************
709// IO
710// *********************************************************************************************************************
711template<typename T>
712std::ostream &operator<<(std::ostream &os, const Vector2<T> &v) {
713 os << "Vector2 [" << v.x << " " << v.y << "]";
714 return os;
715}
716template<typename T>
717std::ostream &operator<<(std::ostream &os, const Vector3<T> &v) {
718 os << "Vector3 [" << v.x << " " << v.y << " " << v.z << "]";
719 return os;
720}
721template<typename T>
722std::ostream &operator<<(std::ostream &os, const Vector4<T> &v) {
723 os << "Vector4 [" << v.x << " " << v.y << " " << v.z << " " << v.w << "]";
724 return os;
725}
726
727// *********************************************************************************************************************
728// TYPEDEFS
729// *********************************************************************************************************************
730using vec2 = Vector2<real_t>;
731using vec3 = Vector3<real_t>;
732using vec4 = Vector4<real_t>;
733using vec3d = Vector3<double>;
734using vec3f = Vector3<float>;
735using vec2f = Vector2<float>;
736using vec2i = Vector2<Interval<real_t>>;
737using vec3i = Vector3<Interval<real_t>>;
738
739} // namespace hermes
740
741// std hash support
742namespace std {
743
746template<typename T> struct hash<hermes::Vector2<T>> {
750 size_t operator()(hermes::Vector2<T> const &v) const {
751 hash<T> hasher;
752 size_t s = 0;
753 // inject x component
754 size_t h = hasher(v.x);
755 h += 0x9e3779b9 + (s << 6) + (s >> 2);
756 s ^= h;
757 // inject y component
758 h = hasher(v.y);
759 h += 0x9e3779b9 + (s << 6) + (s >> 2);
760 s ^= h;
761 return s;
762 }
763};
764
767template<typename T> struct hash<hermes::Vector3<T>> {
771 size_t operator()(hermes::Vector3<T> const &v) const {
772 hash<T> hasher;
773 size_t s = 0;
774 // inject x component
775 size_t h = hasher(v.x);
776 h += 0x9e3779b9 + (s << 6) + (s >> 2);
777 s ^= h;
778 // inject y component
779 h = hasher(v.y);
780 h += 0x9e3779b9 + (s << 6) + (s >> 2);
781 s ^= h;
782 // inject y component
783 h = hasher(v.z);
784 h += 0x9e3779b9 + (s << 6) + (s >> 2);
785 s ^= h;
786 return s;
787 }
788};
789
790} // namespace std
791
792#endif
793
hermes::MathElement
Interface used by all basic geometric entities.
Definition math_element.h:44
hermes::Point3
Geometric 3-dimensional vector (x, y, z)
Definition point.h:148
hermes::Vector2
Geometric 2-dimensional vector (x, y)
Definition vector.h:54
hermes::Vector2::length2
HERMES_DEVICE_CALLABLE T length2() const
Computes squared magnitude.
Definition vector.h:129
hermes::Vector2::xy
Vector2 xy() const
Gets swizzle form (x, y)
Definition vector.h:142
hermes::Vector2::Vector2
HERMES_DEVICE_CALLABLE Vector2(T _x, T _y)
Constructs from component values.
Definition vector.h:68
hermes::Vector2::operator[]
HERMES_DEVICE_CALLABLE T operator[](size_t i) const
Get i-th component.
Definition vector.h:89
hermes::Vector2::right
HERMES_DEVICE_CALLABLE Vector2 right() const
Gets orthogonal vector in right direction.
Definition vector.h:135
hermes::Vector2::yx
Vector2 yx() const
Gets swizzle form (y, x)
Definition vector.h:145
hermes::Vector2::length
HERMES_DEVICE_CALLABLE T length() const
Computes magnitude.
Definition vector.h:132
hermes::Vector2::left
HERMES_DEVICE_CALLABLE Vector2 left() const
Gets orthogonal vector in left direction.
Definition vector.h:138
hermes::Vector2::x
T x
0-th component
Definition vector.h:155
hermes::Vector2::operator[]
HERMES_DEVICE_CALLABLE T & operator[](size_t i)
Get i-th component reference.
Definition vector.h:94
hermes::Vector2::Vector2
HERMES_DEVICE_CALLABLE Vector2()
Default constructor.
Definition vector.h:64
hermes::Vector2::yy
Vector2 yy() const
Gets swizzle form (y, y)
Definition vector.h:151
hermes::Vector2::Vector2
HERMES_DEVICE_CALLABLE Vector2(T f)
Constructs from single component value.
Definition vector.h:74
hermes::Vector2::Vector2
HERMES_DEVICE_CALLABLE Vector2(const Point2< T > &p)
Constructs from geometric point.
Definition vector.h:71
hermes::Vector2::Vector2
HERMES_DEVICE_CALLABLE Vector2(T *f)
Constructs from component array.
Definition vector.h:77
hermes::Vector2::y
T y
1-th component
Definition vector.h:156
hermes::Vector2::xx
Vector2 xx() const
Gets swizzle form (x, x)
Definition vector.h:148
hermes::Vector3
Geometric 3-dimensional vector (x, y, z)
Definition vector.h:166
hermes::Vector3::operator[]
HERMES_DEVICE_CALLABLE T operator[](int i) const
Get i-th component.
Definition vector.h:282
hermes::Vector3::mLength
HERMES_DEVICE_CALLABLE T mLength() const
Computes Manhattan distance.
Definition vector.h:302
hermes::Vector3::Vector3
HERMES_DEVICE_CALLABLE Vector3(const Vector3< Interval< S > > &vi, typename std::enable_if_t< !std::is_same_v< C, Interval< f32 > > &&!std::is_same_v< C, Interval< f64 > > > *=nullptr)
Constructs from interval.
Definition vector.h:201
hermes::Vector3::maxAbsDimension
HERMES_DEVICE_CALLABLE int maxAbsDimension() const
Gets index of component with maximum absolute value.
Definition vector.h:361
hermes::Vector3::hasNaNs
HERMES_DEVICE_CALLABLE bool hasNaNs() const
Check for nans.
Definition vector.h:409
hermes::Vector3::maxAbs
HERMES_DEVICE_CALLABLE T maxAbs() const
Gets maximum absolute component value.
Definition vector.h:331
hermes::Vector3::length
HERMES_DEVICE_CALLABLE T length(typename std::enable_if_t<!std::is_same_v< C, Interval< f32 > > &&!std::is_same_v< C, Interval< f64 > > > *=nullptr) const
Computes vector magnitude.
Definition vector.h:308
hermes::Vector3::length2
HERMES_DEVICE_CALLABLE T length2() const
Computes vector squared magnitude.
Definition vector.h:326
hermes::Vector3::rejectOn
HERMES_DEVICE_CALLABLE Vector3 rejectOn(const Vector3 b)
Rejects this vector on b.
Definition vector.h:401
hermes::Vector3::projectOnto
HERMES_DEVICE_CALLABLE Vector3 projectOnto(const Vector3 &b)
Projects this vector onto b.
Definition vector.h:394
hermes::Vector3::Vector3
HERMES_DEVICE_CALLABLE Vector3(const T *v)
Constructs from component array.
Definition vector.h:187
hermes::Vector3::operator=
HERMES_DEVICE_CALLABLE Vector3 & operator=(const T &v)
Copy assign.
Definition vector.h:213
hermes::Vector3::max
HERMES_DEVICE_CALLABLE T max() const
Gets maximum component value.
Definition vector.h:341
hermes::Vector3::maxDimension
HERMES_DEVICE_CALLABLE int maxDimension() const
Gets index of component with maximum value.
Definition vector.h:351
hermes::Vector3::xy
HERMES_DEVICE_CALLABLE Vector2< T > xy(int i=0, int j=1) const
Gets 2-dimensional swizzle form.
Definition vector.h:292
hermes::Vector3::Vector3
HERMES_DEVICE_CALLABLE Vector3(T _f)
Constructs from single component value.
Definition vector.h:179
hermes::Vector3::length
HERMES_DEVICE_CALLABLE T length(typename std::enable_if_t< std::is_same_v< C, Interval< f32 > >||std::is_same_v< C, Interval< f64 > > > *=nullptr) const
Computes vector magnitude.
Definition vector.h:317
hermes::Vector3::x
T x
0-th component
Definition vector.h:415
hermes::Vector3::Vector3
HERMES_DEVICE_CALLABLE Vector3(T _x, T _y, T _z)
Constructs from component values.
Definition vector.h:184
hermes::Vector3::normalize
HERMES_DEVICE_CALLABLE void normalize()
Normalizes this vector.
Definition vector.h:374
hermes::Vector3::operator[]
HERMES_DEVICE_CALLABLE T & operator[](int i)
Get i-th component reference.
Definition vector.h:287
hermes::Vector3::Vector3
HERMES_DEVICE_CALLABLE Vector3()
Default constructor.
Definition vector.h:176
hermes::Vector3::z
T z
2-th component
Definition vector.h:417
hermes::Vector3::Vector3
HERMES_DEVICE_CALLABLE Vector3(const Point3< T > &p)
Casts from geometric point.
Definition vector.h:195
hermes::Vector3::y
T y
1-th component
Definition vector.h:416
hermes::Vector3::normalized
HERMES_DEVICE_CALLABLE Vector3 normalized() const
Gets a normalized copy of this vector.
Definition vector.h:386
hermes::Vector4
Geometric 4-dimensional point (x, y, z, w)
Definition vector.h:425
hermes::Vector4::y
T y
1-th component
Definition vector.h:517
hermes::Vector4::operator[]
HERMES_DEVICE_CALLABLE T & operator[](int i)
Get i-th component reference.
Definition vector.h:497
hermes::Vector4::z
T z
2-th component
Definition vector.h:518
hermes::Vector4::x
T x
0-th component
Definition vector.h:516
hermes::Vector4::xy
HERMES_DEVICE_CALLABLE Vector2< T > xy()
Gets first 2 components.
Definition vector.h:500
hermes::Vector4::operator[]
HERMES_DEVICE_CALLABLE T operator[](int i) const
Get i-th component.
Definition vector.h:492
hermes::Vector4::Vector4
HERMES_DEVICE_CALLABLE Vector4()
Default constructor.
Definition vector.h:431
hermes::Vector4::length2
HERMES_DEVICE_CALLABLE T length2() const
Computes vector squared magnitude.
Definition vector.h:509
hermes::Vector4::length
HERMES_DEVICE_CALLABLE T length() const
Computes vector magnitude.
Definition vector.h:512
hermes::Vector4::xyz
HERMES_DEVICE_CALLABLE Vector3< T > xyz()
Gets first 3 components.
Definition vector.h:503
hermes::Vector4::w
T w
3-th component
Definition vector.h:519
hermes::Vector4::Vector4
HERMES_DEVICE_CALLABLE Vector4(T _x, T _y, T _z, T _w)
Construct from component values.
Definition vector.h:437
hermes::cuda_utils::operator<<
std::ostream & operator<<(std::ostream &o, const LaunchInfo &info)
LaunchInfo support for std::ostream << operator.
Definition cuda_utils.h:234
debug.h
Debug, logging and assertion macros.
HERMES_DEVICE_CALLABLE
#define HERMES_DEVICE_CALLABLE
Specifies that the function can be called from both host and device sides.
Definition defs.h:45
HERMES_CHECK_EXP
#define HERMES_CHECK_EXP(expr)
Warns if expression is false.
Definition debug.h:95
index.h
Set of multi-dimensional integer iterators.
ARITHMETIC_OP
#define ARITHMETIC_OP(OP)
asd
Definition index.h:59
interval.h
Numeric interval.
hermes::project
HERMES_DEVICE_CALLABLE Vector2< T > project(const Vector2< T > &v, const Normal2< T > &n)
projects v on the surface with normal n
Definition normal.h:193
hermes::dot
HERMES_DEVICE_CALLABLE T dot(const Normal3< T > &n, const Vector3< T > &v)
Computes dot product with vector.
Definition normal.h:237
hermes::normalize
HERMES_DEVICE_CALLABLE Normal3< T > normalize(const Normal3< T > &normal)
Computes normalized copy.
Definition normal.h:201
numeric.h
Number functions.
hermes::Check::is_equal
static HERMES_DEVICE_CALLABLE constexpr bool is_equal(T a, T b)
Checks if two numbers are at most 1e-8 apart.
Definition numeric.h:847
hermes::Check::is_nan
static HERMES_DEVICE_CALLABLE std::enable_if_t< std::is_floating_point< T >::value, bool > is_nan(T v)
Checks if number representation is nan
Definition numeric.h:884
hermes::Check::is_zero
static HERMES_DEVICE_CALLABLE constexpr bool is_zero(T a)
Checks if number is 0.
Definition numeric.h:834
hermes::Index2
Holds 2-dimensional integer index coordinates.
Definition index.h:50
std::hash< hermes::Vector2< T > >::operator()
size_t operator()(hermes::Vector2< T > const &v) const
Computes hash for a given vector.
Definition vector.h:750
std::hash< hermes::Vector3< T > >::operator()
size_t operator()(hermes::Vector3< T > const &v) const
Computes hash for a given vector.
Definition vector.h:771
hermes::reject
HERMES_DEVICE_CALLABLE Vector3< T > reject(const Vector3< T > &a, const Vector3< T > &b)
Rejects one vector on another.
Definition vector.h:627
hermes::triple
HERMES_DEVICE_CALLABLE T triple(const Vector3< T > &a, const Vector3< T > &b, const Vector3< T > &c)
Computes the triple product between 3 vectors.
Definition vector.h:570
hermes::orthonormal
HERMES_DEVICE_CALLABLE Vector2< T > orthonormal(const Vector2< T > &v, bool first=true)
Computes vector orthonormal to given vector.
Definition vector.h:597
hermes::cross
HERMES_DEVICE_CALLABLE T cross(const Vector2< T > &a, const Vector2< T > &b)
Computes the cross product between two vectors.
Definition vector.h:550
hermes::tangential
HERMES_DEVICE_CALLABLE void tangential(const Vector3< T > &a, Vector3< T > &b, Vector3< T > &c)
compute the two orthogonal-tangential vectors from a
Definition vector.h:635