cgv
Loading...
Searching...
No Matches
fvec.h
1#pragma once
2
3// Make sure this is the first thing the compiler sees, while preventing warnings if
4// it happened to already be defined by something else including this header
5#ifndef _USE_MATH_DEFINES
6 #define _USE_MATH_DEFINES 1
7#endif
8#include <algorithm>
9#include <array>
10#include <cmath>
11#include <cstdint>
12#include <cstring>
13#include <iostream>
14#include <limits>
15#include <sstream>
16
17#include <cgv/type/standard_types.h>
18
19#include "constants.h"
20#include "functions.h"
21
22namespace cgv {
23namespace math {
24
25template <typename T> class vec;
26
28template <typename T, cgv::type::uint32_type N>
29class fvec {
30protected:
31 // the components of the vector
32 T v[N];
33
34public:
35 //@name type definitions
37
38 typedef T value_type;
40 typedef T& reference;
42 typedef const T& const_reference;
44 typedef std::size_t size_type;
46 typedef std::ptrdiff_t difference_type;
48 typedef T* pointer;
50 typedef const T* const_pointer;
52 typedef T* iterator;
54 typedef const T* const_iterator;
56 typedef std::reverse_iterator<iterator> reverse_iterator;
58 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
60 enum { dims = N };
62
63 //@name construction and assignment
65
66 fvec() {}
68 fvec(const T& x) { for(unsigned i = 0; i < N; ++i) v[i] = x; }
70 template <uint32_t _N = N, typename std::enable_if<_N >= 2, int>::type = 0>
71 fvec(const T& x, const T& y) { set(x, y); }
73 template <uint32_t _N = N, typename std::enable_if<_N >= 3, int>::type = 0>
74 fvec(const T& x, const T& y, const T& z) { set(x, y, z); }
76 template <uint32_t _N = N, typename std::enable_if<_N >= 4, int>::type = 0>
77 fvec(const T& x, const T& y, const T& z, const T& w) { set(x, y, z, w); }
79 fvec(cgv::type::uint32_type n, const T* a) {
80 cgv::type::uint32_type i, min_n = n < N ? n : N;
81 memmove(v, a, min_n * sizeof(T));
82 for(i = min_n; i < N; ++i) v[i] = T(0);
83 }
85 template <typename S>
86 fvec(cgv::type::uint32_type n, const S* a) {
87 cgv::type::uint32_type i, min_n = n < N ? n : N;
88 for(i = 0; i < min_n; ++i) v[i] = static_cast<T>(a[i]);
89 for(; i < N; ++i) v[i] = T(0);
90 }
92 template <typename S>
93 fvec(const fvec<S, N>& other) { for(unsigned i = 0; i < N; ++i) v[i] = static_cast<T>(other[i]); }
95 template <typename S1, typename S2>
96 fvec(const fvec<S1, N - 1>& other, S2 s) { for(unsigned i = 0; i < N - 1; ++i) v[i] = static_cast<T>(other[i]); v[N - 1] = static_cast<T>(s); }
98 template <typename S>
99 fvec(const fvec<S, N + 1>& other) { for(unsigned i = 0; i < N; ++i) v[i] = static_cast<T>(other[i]); }
101 fvec(const std::array<T, N>& a) : fvec(N, a.data()) {}
103 void assign(const std::array<T, N>& a) { for(unsigned i = 0; i < N; ++i) v[i] = a[i]; }
105 template <uint32_t _N = N, typename std::enable_if<_N >= 2, int>::type = 0>
106 void set(const T& x, const T& y) { v[0] = x; v[1] = y; }
108 template <uint32_t _N = N, typename std::enable_if<_N >= 3, int>::type = 0>
109 void set(const T& x, const T& y, const T& z) { v[0] = x; v[1] = y; v[2] = z; }
111 template <uint32_t _N = N, typename std::enable_if<_N >= 4, int>::type = 0>
112 void set(const T& x, const T& y, const T& z, const T& w) { v[0] = x; v[1] = y; v[2] = z; v[3] = w; }
114 void fill(const T& x) { for(unsigned i = 0; i < N; ++i) v[i] = x; }
116 void zeros() { fill(T(0)); }
118 void zerosh() { for(unsigned i = 0; i < N - 1; ++i) v[i] = T(0); v[N - 1] = T(1); }
120 void ones() { fill(T(1)); }
122 fvec<T, N + 1> lift() const { fvec<T, N + 1> h; (fvec<T, N>&)h = *this; h[N] = T(1); return h; }
124 static fvec<T, N> zeroh() { fvec<T, N> r; r.zerosh(); return r; }
126 vec<T> to_vec() const;
128 static fvec<T, N> from_vec(const vec<T>&);
130
131 //@name access to components
133
134 static cgv::type::uint32_type size() { return N; }
136 T& x() { return v[0]; }
138 const T& x() const { return v[0]; }
140 T& y() { return v[1]; }
142 const T& y() const { return v[1]; }
144 T& z() { return v[2]; }
146 const T& z() const { return v[2]; }
148 T& w() { return v[3]; }
150 const T& w() const { return v[3]; }
152 T& operator[](int i) { return v[i]; }
154 const T& operator[](int i) const { return v[i]; }
156 T& operator()(int i) { return v[i]; }
158 const T& operator()(int i) const { return v[i]; }
160 T* data() { return v; }
162 const T* data() const { return v; }
164
165 //@name iterators
167
168 iterator begin() { return v; }
170 iterator end() { return v + N; }
172 const_iterator begin() const { return v; }
174 const_iterator end() const { return v + N; }
176 reverse_iterator rbegin() { return reverse_iterator(end()); }
178 reverse_iterator rend() { return reverse_iterator(begin()); }
180 const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
182 const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
184
185 //@name operators
187
188 fvec<T, N>& operator += (const T& s) { for(unsigned i = 0; i < N; ++i) v[i] += s; return *this; }
190 fvec<T, N>& operator -= (const T& s) { for(unsigned i = 0; i < N; ++i) v[i] -= s; return *this; }
192 fvec<T, N>& operator *= (const T& s) { for(unsigned i = 0; i < N; ++i) v[i] *= s; return *this; }
194 fvec<T, N>& operator /= (const T& s) { for(unsigned i = 0; i < N; ++i) v[i] /= s; return *this; }
196 template <typename S>
197 fvec<T, N>& operator += (const fvec<S, N>& v) { for(unsigned i = 0; i < N; ++i) this->v[i] += static_cast<T>(v[i]); return *this; }
199 template <typename S>
200 fvec<T, N>& operator -= (const fvec<S, N>& v) { for(unsigned i = 0; i < N; ++i) this->v[i] -= static_cast<T>(v[i]); return *this; }
202 template <typename S>
203 fvec<T, N>& operator *= (const fvec<S, N>& v) { for(unsigned i = 0; i < N; ++i) this->v[i] *= static_cast<T>(v[i]); return *this; }
205 template <typename S>
206 fvec<T, N>& operator /= (const fvec<S, N>& v) { for(unsigned i = 0; i < N; ++i) this->v[i] /= static_cast<T>(v[i]); return *this; }
208 template <typename S>
209 fvec<T, N> operator + (const fvec<S, N>& v) const { fvec<T, N> r = *this; r += v; return r; }
211 template <typename S>
212 fvec<T, N> operator - (const fvec<S, N>& v) const { fvec<T, N> r = *this; r -= v; return r; }
214 template <typename S>
215 fvec<T, N> operator * (const fvec<S, N>& v) const { fvec<T, N> r = *this; r *= v; return r; }
217 template <typename S>
218 fvec<T, N> operator / (const fvec<S, N>& v) const { fvec<T, N> r = *this; r /= v; return r; }
220 fvec<T, N> operator + (const T& s) const { fvec<T, N> r = *this; r += s; return r; }
222 fvec<T, N> operator - (const T& s) const { fvec<T, N> r = *this; r -= s; return r; }
224 fvec<T, N> operator * (const T& s) const { fvec<T, N> r = *this; r *= s; return r; }
226 fvec<T, N> operator / (const T& s) const { fvec<T, N> r = *this; r /= s; return r; }
227
229 fvec<T, N> operator - () const { fvec<T, N> r; for(unsigned i = 0; i < N; ++i) r[i] = -v[i]; return r; }
230
232 template <typename S>
233 bool operator == (const fvec<S, N>& v) const {
234 for(unsigned i = 0; i < N; ++i)
235 if(operator[](i) != static_cast<T>(v[i])) return false;
236 return true;
237 }
239 template <typename S>
240 bool operator != (const fvec<S, N>& v) const {
241 for(unsigned i = 0; i < N; ++i)
242 if(operator[](i) != static_cast<T>(v[i])) return true;
243 return false;
244 }
246
247 //@name functions
249
250 T sqr_length() const {
251 T l = 0;
252 for(unsigned i = 0; i < N; ++i)
253 l += v[i] * v[i];
254 return l;
255 }
257 T length() const {
258 return std::sqrt(sqr_length());
259 }
261 void sign() {
262 for(unsigned i = 0; i < N; ++i)
263 v[i] = cgv::math::sign(v[i]);
264 }
266 void step(const fvec<T, N>& r) {
267 for(unsigned i = 0; i < N; ++i)
268 v[i] = cgv::math::step(v[i], r[i]);
269 }
271 void abs() {
272 if(std::numeric_limits<T>::is_signed) {
273 for(unsigned i = 0; i < N; ++i)
274 v[i] = std::abs(v[i]);
275 }
276 }
278 void ceil() {
279 for(unsigned i = 0; i < N; ++i)
280 v[i] = std::ceil(v[i]);
281 }
283 void floor() {
284 for(unsigned i = 0; i < N; ++i)
285 v[i] = std::floor(v[i]);
286 }
288 void round() {
289 for(unsigned i = 0; i < N; ++i)
290 v[i] = std::round(v[i]);
291 }
293 T normalize() {
294 T l = length();
295 T inv_l = T(1) / l;
296 for(unsigned i = 0; i < N; ++i)
297 v[i] *= inv_l;
298 return l;
299 }
301 T safe_normalize() {
302 T l = length();
303 if(std::abs(l) < std::numeric_limits<T>::epsilon())
304 return T(0);
305 T inv_l = T(1) / l;
306 for(unsigned i = 0; i < N; ++i)
307 v[i] *= inv_l;
308 return l;
309 }
311};
312
314#define CGV_MATH_FVEC_DECLARED
315
317template<typename T, cgv::type::uint32_type N>
318fvec<T, N> normalize(const fvec<T, N>& v) { fvec<T, N> w(v); w.normalize(); return w; }
319
321template<typename T, cgv::type::uint32_type N>
322fvec<T, N> safe_normalize(const fvec<T, N>& v) { fvec<T, N> w(v); w.safe_normalize(); return w; }
323
325template<typename T, cgv::type::uint32_type N>
326std::ostream& operator<<(std::ostream& out, const fvec<T, N>& v) {
327 for(unsigned i = 0; i < N - 1; ++i)
328 out << v[i] << " ";
329 out << v[N - 1];
330 return out;
331
332}
333
335template<typename T, cgv::type::uint32_type N>
336std::istream& operator>>(std::istream& in, fvec<T, N>& v) {
337 for(unsigned i = 0; i < N; ++i) {
338 in >> v[i];
339 if(in.fail() && i == 1) {
340 for(unsigned i = 1; i < N; ++i)
341 v[i] = v[0];
342 break;
343 }
344 }
345 return in;
346}
347
349template<typename T, cgv::type::uint32_type N>
350std::string to_string(const fvec<T, N>& v) {
351 std::ostringstream ss;
352 ss << v;
353 return ss.str();
354}
355
357template<typename T, cgv::type::uint32_type N>
358bool from_string(const std::string& s, fvec<T, N>& v) {
359 std::istringstream iss(s);
360 iss >> v;
361 return !iss.fail();
362}
363
365template <typename T, cgv::type::uint32_type N>
366fvec<T, N> operator * (const T& s, const fvec<T, N>& v) { fvec<T, N> r = v; r *= s; return r; }
367
369template <typename T, cgv::type::uint32_type N>
370fvec<T, N> operator / (const T& s, const fvec<T, N>& v) {
371 fvec<T, N> r;
372 for(unsigned i = 0; i < N; ++i)
373 r[i] = s / v[i];
374 return r;
375}
376
378template <typename T, typename S, cgv::type::uint32_type N>
379inline T dot(const fvec<T, N>& v, const fvec<S, N>& w) {
380 T r = 0;
381 for(unsigned i = 0; i < N; ++i)
382 r += static_cast<T>(v[i] * w[i]);
383 return r;
384}
385
388template <typename T, typename S, cgv::type::uint32_type N>
389inline S dot_pos(const fvec<T, N>& v, const fvec<S, N + 1>& w) {
390 T r = 0;
391 for(unsigned i = 0; i < N; ++i)
392 r += v[i] * w[i];
393 return r + w[N];
394}
397template <typename T, typename S, cgv::type::uint32_type N>
398inline S dot_pos(const fvec<T, N + 1>& v, const fvec<S, N>& w) {
399 T r = 0;
400 for(unsigned i = 0; i < N; ++i)
401 r += v[i] * w[i];
402 return r + v[N];
403}
404
407template <typename T, typename S, cgv::type::uint32_type N>
408inline S dot_dir(const fvec<T, N>& v, const fvec<S, N + 1>& w) {
409 T r = 0;
410 for(unsigned i = 0; i < N; ++i)
411 r += v[i] * w[i];
412 return r;
413}
416template <typename T, typename S, cgv::type::uint32_type N>
417inline S dot_dir(const fvec<T, N + 1>& v, const fvec<S, N>& w) {
418 T r = 0;
419 for(unsigned i = 0; i < N; ++i)
420 r += v[i] * w[i];
421 return r;
422}
423
425template <typename T, cgv::type::uint32_type N>
426inline fvec<T, N> cross(const fvec<T, N>& v, const fvec<T, N>& w) {
427 fvec<T, N> r(3);
428 r[0] = v[1] * w[2] - v[2] * w[1];
429 r[1] = v[2] * w[0] - v[0] * w[2];
430 r[2] = v[0] * w[1] - v[1] * w[0];
431 return r;
432}
433
435template <typename T, cgv::type::uint32_type N>
436inline T sqr_length(const fvec<T, N>& v) { return dot(v, v); }
437
439template <typename T, cgv::type::uint32_type N>
440inline T length(const fvec<T, N>& v) { return std::sqrt(dot(v, v)); }
441
443template <typename T, cgv::type::uint32_type N>
444inline fvec<T, N> sign(const fvec<T, N>& v) { fvec<T, N> r(v); r.sign(); return r; }
445
447template <typename T, cgv::type::uint32_type N>
448inline fvec<T, N> step(const fvec<T, N>& a, const fvec<T, N>& b) { fvec<T, N> r(a); r.step(b); return r; }
449
451template <typename T, cgv::type::uint32_type N>
452inline fvec<T, N> abs(const fvec<T, N>& v) { fvec<T, N> r(v); r.abs(); return r; }
453
455template <typename T, cgv::type::uint32_type N>
456inline fvec<T, N> round(const fvec<T, N>& v) { fvec<T, N> r(v); r.round(); return r; }
457
459template <typename T, cgv::type::uint32_type N>
460inline fvec<T, N> floor(const fvec<T, N>& v) { fvec<T, N> r(v); r.floor(); return r; }
461
463template <typename T, cgv::type::uint32_type N>
464inline fvec<T, N> ceil(const fvec<T, N>& v) { fvec<T, N> r(v); r.ceil(); return r; }
465
467template <typename T, cgv::type::uint32_type N>
468inline fvec<T, N + 1> hom(const fvec<T, N>& v) {
469 fvec<T, N + 1> h;
470 for(unsigned i = 0; i < N; ++i)
471 h[i] = v[i];
472 h[N] = 1;
473 return h;
474}
475
477template <typename T, cgv::type::uint32_type N>
478T min_value(const fvec<T, N>& v) {
479 return *(std::min_element(v.begin(), v.end()));
480}
481
483template <typename T, cgv::type::uint32_type N>
484unsigned min_index(const fvec<T, N>& v) {
485 return static_cast<unsigned>(std::distance(v.begin(), std::min_element(v.begin(), v.end())));
486}
487
489template <typename T, cgv::type::uint32_type N>
490T max_value(const fvec<T, N>& v) {
491 return *(std::max_element(v.begin(), v.end()));
492}
493
495template <typename T, cgv::type::uint32_type N>
496unsigned max_index(const fvec<T, N>& v) {
497 return static_cast<unsigned>(std::distance(v.begin(), std::max_element(v.begin(), v.end())));
498}
499
501template <typename T, cgv::type::uint32_type N>
502const fvec<T, N> lerp(const fvec<T, N>& v0, const fvec<T, N>& v1, T t) {
503 return (T(1) - t) * v0 + t * v1;
504}
505
507template <typename T, cgv::type::uint32_type N>
508const fvec<T, N> lerp(const fvec<T, N>& v0, const fvec<T, N>& v1, const fvec<T, N>& t) {
509 return (fvec<T, N>(1) - t) * v0 + t * v1;
510}
511
513template <typename T, cgv::type::uint32_type N>
514const fvec<T, N> slerp(const fvec<T, N>& v0, const fvec<T, N>& v1, T t) {
515 T dotv0v1 = dot(v0, v1);
516 // clamp between [-1,1]
517 if(dotv0v1 < -1)
518 dotv0v1 = -1;
519
520 if(dotv0v1 > 1)
521 dotv0v1 = 1;
522
523 T theta = std::acos(dotv0v1) * t;
524 auto v2 = normalize(v1 - (dotv0v1)*v0);
525 return T(std::cos(theta)) * v0 + T(std::sin(theta)) * v2;
526}
527
529template <typename T, cgv::type::uint32_type N>
530const fvec<T, N> min(const fvec<T, N>& v, T s) {
531 fvec<T, N> c;
532 for(unsigned i = 0; i < N; ++i)
533 c(i) = std::min(v[i], s);
534 return c;
535}
536
538template <typename T, cgv::type::uint32_type N>
539const fvec<T, N> min(const fvec<T, N>& v0, const fvec<T, N>& v1) {
540 fvec<T, N> c;
541 for(unsigned i = 0; i < N; ++i)
542 c[i] = std::min(v0[i], v1[i]);
543 return c;
544}
545
547template <typename T, cgv::type::uint32_type N>
548const fvec<T, N> max(const fvec<T, N>& v, T s) {
549 fvec<T, N> c;
550 for(unsigned i = 0; i < N; ++i)
551 c[i] = std::max(v[i], s);
552 return c;
553}
554
556template <typename T, cgv::type::uint32_type N>
557const fvec<T, N> max(const fvec<T, N>& v0, const fvec<T, N>& v1) {
558 fvec<T, N> c;
559 for(unsigned i = 0; i < N; ++i)
560 c[i] = std::max(v0[i], v1[i]);
561 return c;
562}
563
565template <typename T, cgv::type::uint32_type N>
566const fvec<T, N> clamp(const fvec<T, N>& v, T l, T r) {
567 fvec<T, N> c;
568 for(unsigned i = 0; i < N; ++i)
569 c[i] = cgv::math::clamp(v[i], l, r);
570 return c;
571}
572
574template <typename T, cgv::type::uint32_type N>
575const fvec<T, N> clamp(const fvec<T, N>& v, const fvec<T, N>& vl, const fvec<T, N>& vr) {
576 fvec<T, N> c;
577 for(unsigned i = 0; i < N; ++i)
578 c[i] = cgv::math::clamp(v[i], vl[i], vr[i]);
579 return c;
580}
581
583template <typename T, cgv::type::uint32_type N>
584const fvec<T, N> saturate(const fvec<T, N>& v) {
585 return clamp(v, T(0), T(1));
586}
587
589template <typename T, cgv::type::uint32_type N>
590const fvec<T, N> pow(const fvec<T, N>& v, T e) {
591 fvec<T, N> c;
592 for(unsigned i = 0; i < N; ++i)
593 c[i] = std::pow(v[i], e);
594 return c;
595}
596
598template <typename T, cgv::type::uint32_type N>
599const fvec<T, N> pow(const fvec<T, N>& v, const fvec<T, N>& e) {
600 fvec<T, N> c;
601 for(unsigned i = 0; i < N; ++i)
602 c[i] = std::pow(v[i], e[i]);
603 return c;
604}
605
607template <typename T, cgv::type::uint32_type N>
608fvec<T, N> ortho(const fvec<T, N>& v) = delete;
609
611template <typename T>
612fvec<T, 2> ortho(const fvec<T, 2>& v) {
613 return fvec<T, 2>(-v.y(), v.x());
614}
615
617template <typename T>
618fvec<T, 3> ortho(const fvec<T, 3>& v) {
619 return std::abs(v.x()) > std::abs(v.z()) ? fvec<T, 3>(-v.y(), v.x(), T(0)) : fvec<T, 3>(T(0), -v.z(), v.y());
620}
621
623template <typename T, cgv::type::uint32_type N>
624T to_angle(fvec<T, N> v) = delete;
625
627template <typename T>
628T to_angle(fvec<T, 2> v) {
629 v.normalize();
630 float a = std::atan2(v.y(), v.x());
631 if(a < T(0))
632 a += T(2) * static_cast<T>(cgv::math::constants::pi);
633 return a;
634}
635
637template <typename T, cgv::type::uint32_type N>
638T to_direction(fvec<T, N> v) = delete;
639
641template <typename T>
642fvec<T, 2> to_direction(T a) {
643 return fvec<T, 2>(std::cos(a), std::sin(a));
644}
645
646} // namespace math
647
650
652typedef cgv::math::fvec<bool, 2> bvec2;
654typedef cgv::math::fvec<bool, 3> bvec3;
656typedef cgv::math::fvec<bool, 4> bvec4;
657
659typedef cgv::math::fvec<float, 2> vec2;
661typedef cgv::math::fvec<float, 3> vec3;
663typedef cgv::math::fvec<float, 4> vec4;
664
666typedef cgv::math::fvec<double, 2> dvec2;
668typedef cgv::math::fvec<double, 3> dvec3;
670typedef cgv::math::fvec<double, 4> dvec4;
671
673typedef cgv::math::fvec<int16_t, 2> svec2;
675typedef cgv::math::fvec<int16_t, 3> svec3;
677typedef cgv::math::fvec<int16_t, 4> svec4;
679typedef cgv::math::fvec<uint16_t, 2> usvec2;
681typedef cgv::math::fvec<uint16_t, 3> usvec3;
683typedef cgv::math::fvec<uint16_t, 4> usvec4;
684
686typedef cgv::math::fvec<int32_t, 2> ivec2;
688typedef cgv::math::fvec<int32_t, 3> ivec3;
690typedef cgv::math::fvec<int32_t, 4> ivec4;
692typedef cgv::math::fvec<uint32_t, 2> uvec2;
694typedef cgv::math::fvec<uint32_t, 3> uvec3;
696typedef cgv::math::fvec<uint32_t, 4> uvec4;
697
699typedef cgv::math::fvec<int64_t, 2> lvec2;
701typedef cgv::math::fvec<int64_t, 3> lvec3;
703typedef cgv::math::fvec<int64_t, 4> lvec4;
705typedef cgv::math::fvec<uint64_t, 2> ulvec2;
707typedef cgv::math::fvec<uint64_t, 3> ulvec3;
709typedef cgv::math::fvec<uint64_t, 4> ulvec4;
710
712
713} // namespace cgv
714
715#include "vec.h"
716
717namespace cgv {
718namespace math {
719
721template <typename T, cgv::type::uint32_type N>
722vec<T> fvec<T,N>::to_vec() const {
723 vec<T> r;
724 r.set_extern_data(N,const_cast<T*>(v));
725 return r;
726}
727
729template <typename T, cgv::type::uint32_type N>
730fvec<T, N> fvec<T, N>::from_vec(const vec<T>& v)
731{
732 return fvec<T, N>(N < v.dim() ? N : v.dim(), &v[0]);
733}
734
735} // namespace math
736} // namespace cgv
737
738
739/*
740#include <cgv/utils/convert_string.h>
741#include <cgv/type/info/type_name.h>
742
743namespace cgv {
744namespace type {
745namespace info {
746
747template <typename T, cgv::type::uint32_type N>
748struct type_name<cgv::math::fvec<T,N> >
749{
750 static const char* get_name() {
751 static std::string name;
752 if (name.empty()) {
753 name = "fvec<";
754 name += type_name<T>::get_name();
755 name += ',';
756 name += cgv::utils::to_string(N);
757 name += '>';
758 }
759 return name.c_str();
760 }
761};
762
763}
764}
765}
766*/
cgv::base::single_method_action
complete implementation of method actions that only call one method when entering a node
Definition action.h:113
cgv::math::fvec
A vector with zero based index.
Definition fvec.h:29
cgv::math::fvec::rend
reverse_iterator rend()
return a reverse iterator past the last component of the reversed *this that corresponds to the compo...
Definition fvec.h:178
cgv::math::fvec::fvec
fvec(const fvec< S, N+1 > &other)
construct from vector of one dimension higher by dropping the highest dimension
Definition fvec.h:99
cgv::math::fvec::z
T & z()
return third component
Definition fvec.h:144
cgv::math::fvec::y
T & y()
return second component
Definition fvec.h:140
cgv::math::fvec::safe_normalize
T safe_normalize()
normalize the vector using the L2-Norm and return the length; if length is zero the vector remains un...
Definition fvec.h:301
cgv::math::fvec::normalize
T normalize()
normalize the vector using the L2-Norm and return the length
Definition fvec.h:293
cgv::math::fvec::zeroh
static fvec< T, N > zeroh()
constuct a homogeneous zero-vector (yields same result as calling fvec<T, N-1>(0)....
Definition fvec.h:124
cgv::math::fvec::operator()
T & operator()(int i)
return a reference to the component at specified index i
Definition fvec.h:156
cgv::math::fvec::round
void round()
round componentwise
Definition fvec.h:288
cgv::math::fvec::z
const T & z() const
return third component
Definition fvec.h:146
cgv::math::fvec::operator==
bool operator==(const fvec< S, N > &v) const
test for equality
Definition fvec.h:233
cgv::math::fvec::operator*=
fvec< T, N > & operator*=(const T &s)
in place multiplication with s
Definition fvec.h:192
cgv::math::fvec::operator*
fvec< T, N > operator*(const fvec< S, N > &v) const
componentwise vector multiplication
Definition fvec.h:215
cgv::math::fvec::operator-=
fvec< T, N > & operator-=(const T &s)
in place subtraction by scalar s
Definition fvec.h:190
cgv::math::fvec::operator[]
T & operator[](int i)
return a reference to the component at specified index i
Definition fvec.h:152
cgv::math::fvec::operator/=
fvec< T, N > & operator/=(const T &s)
in place division by scalar s
Definition fvec.h:194
cgv::math::fvec::sign
void sign()
componentwise sign values
Definition fvec.h:261
cgv::math::fvec::begin
iterator begin()
return an iterator to the first component of *this
Definition fvec.h:168
cgv::math::fvec::data
T * data()
return a pointer to the underlying array serving as component storage
Definition fvec.h:160
cgv::math::fvec::sqr_length
T sqr_length() const
square length of vector
Definition fvec.h:250
cgv::math::fvec::length
T length() const
length of the vector L2-Norm
Definition fvec.h:257
cgv::math::fvec::floor
void floor()
floor componentwise
Definition fvec.h:283
cgv::math::fvec::from_vec
static fvec< T, N > from_vec(const vec< T > &)
conversion from vector
Definition fvec.h:730
cgv::math::fvec::operator+
fvec< T, N > operator+(const fvec< S, N > &v) const
vector addition
Definition fvec.h:209
cgv::math::fvec::fvec
fvec(const std::array< T, N > &a)
construct from std::array of same size
Definition fvec.h:101
cgv::math::fvec::operator+=
fvec< T, N > & operator+=(const T &s)
in place addition of a scalar s
Definition fvec.h:188
cgv::math::fvec::rbegin
const_reverse_iterator rbegin() const
return a reverse iterator to the first component of the reversed *this that corresponds to the last c...
Definition fvec.h:180
cgv::math::fvec::operator/
fvec< T, N > operator/(const fvec< S, N > &v) const
componentwise vector division
Definition fvec.h:218
cgv::math::fvec::operator!=
bool operator!=(const fvec< S, N > &v) const
test for inequality
Definition fvec.h:240
cgv::math::fvec::end
const_iterator end() const
return an iterator past the last component of *this
Definition fvec.h:174
cgv::math::fvec::to_vec
vec< T > to_vec() const
conversion to vector type
Definition fvec.h:722
cgv::math::fvec::fvec
fvec(const T &x)
create a vector where all N components are initialized to the constant value x
Definition fvec.h:68
cgv::math::fvec::rend
const_reverse_iterator rend() const
return a reverse iterator past the last component of the reversed *this that corresponds to the compo...
Definition fvec.h:182
cgv::math::fvec::rbegin
reverse_iterator rbegin()
return a reverse iterator to the first component of the reversed *this that corresponds to the last c...
Definition fvec.h:176
cgv::math::fvec::y
const T & y() const
return second component
Definition fvec.h:142
cgv::math::fvec::end
iterator end()
return an iterator past the last component of *this
Definition fvec.h:170
cgv::math::fvec::fvec
fvec()
create an uninitialized vector
Definition fvec.h:66
cgv::math::fvec::operator()
const T & operator()(int i) const
return a reference to the component at specified index i
Definition fvec.h:158
cgv::math::fvec::w
const T & w() const
return fourth component
Definition fvec.h:150
cgv::math::fvec::x
T & x()
return first component
Definition fvec.h:136
cgv::math::fvec::operator-
fvec< T, N > operator-() const
negate the vector
Definition fvec.h:229
cgv::math::fvec::abs
void abs()
componentwise absolute values
Definition fvec.h:271
cgv::math::fvec::x
const T & x() const
return first component
Definition fvec.h:138
cgv::math::fvec::ceil
void ceil()
ceil componentwise
Definition fvec.h:278
cgv::math::fvec::begin
const_iterator begin() const
return an iterator to the first component of *this
Definition fvec.h:172
cgv::math::fvec::w
T & w()
return fourth component
Definition fvec.h:148
cgv::math::fvec::step
void step(const fvec< T, N > &r)
componentwise sign values
Definition fvec.h:266
cgv::math::fvec::data
const T * data() const
return a pointer to the underlying array serving as component storage
Definition fvec.h:162
cgv::math::fvec::operator[]
const T & operator[](int i) const
return a reference to the component at specified index i
Definition fvec.h:154
cgv::math::fvec::assign
void assign(const std::array< T, N > &a)
set to the contents of the given std::array with same size
Definition fvec.h:103
cgv::math::fvec::size
static cgv::type::uint32_type size()
return number of components
Definition fvec.h:134
cgv::math::vec
A column vector class.
Definition vec.h:28
cgv::math::vec::set_extern_data
void set_extern_data(unsigned dim, T *data)
set data pointer to an external data array
Definition vec.h:168
cgv::math::vec::dim
unsigned dim() const
number of elements
Definition vec.h:61
cgv::utils::to_string
std::string to_string(const std::string &v, unsigned int w, unsigned int p, bool)
specialization of conversion from string to strings
Definition convert_string.cxx:7
cgv::utils::from_string
bool from_string(std::string &v, const std::string &s)
specialization to extract string value from string
Definition convert_string.cxx:13
cgv::utils::min_value
T min_value(ForwardIt first, ForwardIt last, T fallback)
Find the minimum value in the range [first, last) or return fallback if the range is empty.
Definition algorithm.h:59
cgv::utils::max_value
T max_value(ForwardIt first, ForwardIt last, T fallback)
Find the maximum value in the range [first, last) or return fallback if the range is empty.
Definition algorithm.h:91
cgv
the cgv namespace
Definition print.h:11
cgv::lvec2
cgv::math::fvec< int64_t, 2 > lvec2
declare type of 2d 64 bit integer vectors
Definition fvec.h:699
cgv::usvec4
cgv::math::fvec< uint16_t, 4 > usvec4
declare type of 4d 16 bit unsigned integer vectors
Definition fvec.h:683
cgv::vec4
cgv::math::fvec< float, 4 > vec4
declare type of 4d single precision floating point vectors (used for homogeneous coordinates)
Definition fvec.h:663
cgv::ulvec4
cgv::math::fvec< uint64_t, 4 > ulvec4
declare type of 4d 64 bit unsigned integer vectors
Definition fvec.h:709
cgv::dvec4
cgv::math::fvec< double, 4 > dvec4
declare type of 4d double precision floating point vectors (used for homogeneous coordinates)
Definition fvec.h:670
cgv::dvec3
cgv::math::fvec< double, 3 > dvec3
declare type of 3d double precision floating point vectors
Definition fvec.h:668
cgv::uvec3
cgv::math::fvec< uint32_t, 3 > uvec3
declare type of 3d 32 bit unsigned integer vectors
Definition fvec.h:694
cgv::ivec3
cgv::math::fvec< int32_t, 3 > ivec3
declare type of 3d 32 bit integer vectors
Definition fvec.h:688
cgv::ivec4
cgv::math::fvec< int32_t, 4 > ivec4
declare type of 4d 32 bit integer vectors
Definition fvec.h:690
cgv::uvec4
cgv::math::fvec< uint32_t, 4 > uvec4
declare type of 4d 32 bit unsigned integer vectors
Definition fvec.h:696
cgv::ivec2
cgv::math::fvec< int32_t, 2 > ivec2
declare type of 2d 32 bit integer vectors
Definition fvec.h:686
cgv::svec3
cgv::math::fvec< int16_t, 3 > svec3
declare type of 3d 16 bit integer vectors
Definition fvec.h:675
cgv::usvec3
cgv::math::fvec< uint16_t, 3 > usvec3
declare type of 3d 16 bit unsigned integer vectors
Definition fvec.h:681
cgv::vec2
cgv::math::fvec< float, 2 > vec2
declare type of 2d single precision floating point vectors
Definition fvec.h:659
cgv::lvec3
cgv::math::fvec< int64_t, 3 > lvec3
declare type of 3d 64 bit integer vectors
Definition fvec.h:701
cgv::bvec4
cgv::math::fvec< bool, 4 > bvec4
declare type of 4d boolean vectors
Definition fvec.h:656
cgv::vec3
cgv::math::fvec< float, 3 > vec3
declare type of 3d single precision floating point vectors
Definition fvec.h:661
cgv::dvec2
cgv::math::fvec< double, 2 > dvec2
declare type of 2d double precision floating point vectors
Definition fvec.h:666
cgv::usvec2
cgv::math::fvec< uint16_t, 2 > usvec2
declare type of 2d 16 bit unsigned integer vectors
Definition fvec.h:679
cgv::uvec2
cgv::math::fvec< uint32_t, 2 > uvec2
declare type of 2d 32 bit unsigned integer vectors
Definition fvec.h:692
cgv::svec2
cgv::math::fvec< int16_t, 2 > svec2
declare type of 2d 16 bit integer vectors
Definition fvec.h:673
cgv::ulvec3
cgv::math::fvec< uint64_t, 3 > ulvec3
declare type of 3d 64 bit unsigned integer vectors
Definition fvec.h:707
cgv::lvec4
cgv::math::fvec< int64_t, 4 > lvec4
declare type of 4d 64 bit integer vectors
Definition fvec.h:703
cgv::bvec3
cgv::math::fvec< bool, 3 > bvec3
declare type of 3d boolean vectors
Definition fvec.h:654
cgv::svec4
cgv::math::fvec< int16_t, 4 > svec4
declare type of 4d 16 bit integer vectors
Definition fvec.h:677
cgv::bvec2
cgv::math::fvec< bool, 2 > bvec2
declare type of 2d boolean vectors
Definition fvec.h:652
cgv::ulvec2
cgv::math::fvec< uint64_t, 2 > ulvec2
declare type of 2d 64 bit unsigned integer vectors
Definition fvec.h:705
vr
the vr namespace for virtual reality support
Definition gl_vr_display.cxx:5
vr::operator<<
std::ostream & operator<<(std::ostream &os, const vr_device_info &di)
stream out operator for device infos
Definition vr_info.cxx:10