MorphoGraphX
Vector.hpp
Go to the documentation of this file.
1 //
2 // This file is part of MorphoGraphX - http://www.MorphoGraphX.org
3 // Copyright (C) 2012-2015 Richard S. Smith and collaborators.
4 //
5 // If you use MorphoGraphX in your work, please cite:
6 // http://dx.doi.org/10.7554/eLife.05864
7 //
8 // MorphoGraphX is free software, and is licensed under under the terms of the
9 // GNU General (GPL) Public License version 2.0, http://www.gnu.org/licenses.
10 //
11 #ifndef __VECTOR_HPP
12 #define __VECTOR_HPP
13 
20 #include <Config.hpp>
21 
22 #include <cuda/CudaGlobal.hpp>
23 #include <StaticAssert.hpp>
24 
25 #include <cassert>
26 #include <cmath>
27 #include <cstdarg>
28 #include <iostream>
29 #include <math.h>
30 
31 #ifndef COMPILE_CUDA
32 # include <QTextStream>
33 #endif
34 
35 namespace mgx { namespace util {
47  template <size_t dim, class T = float> class Vector {
48  protected:
49  T elems[dim];
50 
51  public:
52  typedef T value_type;
53  typedef T& reference_type;
54  typedef const T& const_reference_type;
55  typedef T* pointer_type;
56  typedef const T* const_pointer_type;
57  typedef T* iterator;
58  typedef const T* const_iterator;
59 
63  CU_HOST_DEVICE
64  Vector(const Vector& vec)
65  {
66  for(size_t i = 0; i < dim; i++)
67  elems[i] = vec[i];
68  }
69 
73  template <class T1> CU_HOST_DEVICE Vector(const Vector<dim, T1>& vec)
74  {
75  for(size_t i = 0; i < dim; ++i)
76  elems[i] = vec[i];
77  }
78 
82  template <size_t d1, class T1> CU_HOST_DEVICE explicit Vector(const Vector<d1, T1>& vec)
83  {
84  if(d1 < dim) {
85  for(size_t i = 0; i < d1; ++i)
86  elems[i] = vec[i];
87  for(size_t i = d1; i < dim; ++i)
88  elems[i] = 0;
89  } else {
90  for(size_t i = 0; i < dim; ++i)
91  elems[i] = vec[i];
92  }
93  }
94 
103  template <class Vec> CU_HOST_DEVICE explicit Vector(const Vec& el)
104  {
105  for(size_t i = 0; i < dim; i++)
106  elems[i] = T(el[i]);
107  }
108 
112  CU_HOST_DEVICE
113  explicit Vector(const T& x = T())
114  {
115  for(size_t i = 0; i < dim; ++i)
116  elems[i] = x;
117  }
118 
122  CU_HOST_DEVICE
123  explicit Vector(const T& x, const T& y)
124  {
125  STATIC_ASSERT(dim == 2);
126  elems[0] = x;
127  elems[1] = y;
128  }
129 
133  CU_HOST_DEVICE
134  explicit Vector(const T& x, const T& y, const T& z)
135  {
136  STATIC_ASSERT(dim == 3);
137  elems[0] = x;
138  elems[1] = y;
139  elems[2] = z;
140  }
141 
145  CU_HOST_DEVICE
146  explicit Vector(const T& x, const T& y, const T& z, const T& t)
147  {
148  STATIC_ASSERT(dim == 4);
149  elems[0] = x;
150  elems[1] = y;
151  elems[2] = z;
152  elems[3] = t;
153  }
154 
158  CU_HOST_DEVICE
159  Vector(const T& x, const T& y, const T& z, const T& a, const T& b)
160  {
161  STATIC_ASSERT(dim == 5);
162  elems[0] = x;
163  elems[1] = y;
164  elems[2] = z;
165  elems[3] = a;
166  elems[4] = b;
167  }
168 
172  CU_HOST_DEVICE
173  Vector(const T& x, const T& y, const T& z, const T& a, const T& b, const T& c)
174  {
175  STATIC_ASSERT(dim == 6);
176  elems[0] = x;
177  elems[1] = y;
178  elems[2] = z;
179  elems[3] = a;
180  elems[4] = b;
181  elems[5] = c;
182  }
183 
187  CU_HOST_DEVICE
188  Vector(const T& x, const T& y, const T& z, const T& a, const T& b, const T& c, const T& d)
189  {
190  STATIC_ASSERT(dim == 7);
191  elems[0] = x;
192  elems[1] = y;
193  elems[2] = z;
194  elems[3] = a;
195  elems[4] = b;
196  elems[5] = c;
197  elems[6] = d;
198  }
199 
203  CU_HOST_DEVICE
204  Vector(const T& a, const T& b, const T& c, const T& d, const T& e, const T& f, const T& g, const T& h, const T& i,
205  const T& j, const T& k, const T& l)
206  {
207  STATIC_ASSERT(dim == 12);
208  elems[0] = a;
209  elems[1] = b;
210  elems[2] = c;
211  elems[3] = d;
212  elems[4] = e;
213  elems[5] = f;
214  elems[6] = g;
215  elems[7] = h;
216  elems[8] = i;
217  elems[9] = j;
218  elems[10] = k;
219  elems[11] = l;
220  }
221 
225  CU_HOST_DEVICE
226  static size_t size() {
227  return dim;
228  }
229 
233  CU_HOST_DEVICE
234  T* data() {
235  return elems;
236  }
237 
241  CU_HOST_DEVICE
242  iterator begin() {
243  return elems;
244  }
248  CU_HOST_DEVICE
249  const_iterator begin() const {
250  return elems;
251  }
252 
256  CU_HOST_DEVICE
257  iterator end() {
258  return elems + dim;
259  }
263  CU_HOST_DEVICE
264  const_iterator end() const {
265  return elems + dim;
266  }
267 
271  CU_HOST_DEVICE
272  const T* c_data() const {
273  return elems;
274  }
275 
279  CU_HOST_DEVICE
280  Vector operator-(void) const
281  {
282  Vector ans;
283  for(size_t i = 0; i < dim; i++)
284  ans[i] = -elems[i];
285 
286  return ans;
287  }
288 
292  CU_HOST_DEVICE
293  Vector operator+(const Vector& vec) const
294  {
295  Vector ans(*this);
296  ans += vec;
297  return ans;
298  }
299 
303  CU_HOST_DEVICE
304  Vector operator-(const Vector& vec) const
305  {
306  Vector ans(*this);
307  ans -= vec;
308  return ans;
309  }
310 
314  CU_HOST_DEVICE
315  Vector mult(const Vector& vec) const
316  {
317  Vector ans;
318  for(size_t i = 0; i < dim; i++)
319  ans[i] = elems[i] * vec.elems[i];
320  return ans;
321  }
322 
326  CU_HOST_DEVICE
327  Vector operator*(const T& scalar) const
328  {
329  Vector ans(*this);
330  ans *= scalar;
331  return ans;
332  }
333 
337  CU_HOST_DEVICE
338  Vector operator/(const T& scalar) const
339  {
340  Vector ans(*this);
341  ans /= scalar;
342  return ans;
343  }
344 
348  CU_HOST_DEVICE
349  Vector operator/(const Vector& vec) const
350  {
351  Vector ans = *this;
352  ans /= vec;
353  return ans;
354  }
355 
359  CU_HOST_DEVICE
360  Vector& operator/=(const Vector& vec)
361  {
362  for(size_t i = 0; i < dim; ++i)
363  elems[i] /= vec.elems[i];
364  return *this;
365  }
366 
370  CU_HOST_DEVICE
371  friend Vector operator*(const T& scalar, const Vector& vec)
372  {
373  Vector ans;
374  for(size_t i = 0; i < dim; i++)
375  ans[i] = scalar * vec.elems[i];
376 
377  return ans;
378  }
379 
383  CU_HOST_DEVICE
384  T operator*(const Vector& vec) const
385  {
386  T ans = 0;
387  for(size_t i = 0; i < dim; i++)
388  ans += elems[i] * vec.elems[i];
389 
390  return ans;
391  }
392 
396  CU_HOST_DEVICE
397  Vector& operator=(const Vector& vec)
398  {
399  for(size_t i = 0; i < dim; i++)
400  elems[i] = vec.elems[i];
401 
402  return (*this);
403  }
404 
408  CU_HOST_DEVICE
409  Vector& operator+=(const Vector& vec)
410  {
411  for(size_t i = 0; i < dim; i++)
412  elems[i] += vec.elems[i];
413  return *this;
414  }
415 
419  CU_HOST_DEVICE
420  Vector& operator+=(const T& val)
421  {
422  for(size_t i = 0; i < dim; i++)
423  elems[i] += val;
424  return *this;
425  }
426 
430  CU_HOST_DEVICE
431  Vector& operator-=(const Vector& vec)
432  {
433  for(size_t i = 0; i < dim; i++)
434  elems[i] -= vec.elems[i];
435  return *this;
436  }
437 
441  CU_HOST_DEVICE
442  Vector& operator-=(const T& val)
443  {
444  for(size_t i = 0; i < dim; i++)
445  elems[i] -= val;
446  return *this;
447  }
448 
452  CU_HOST_DEVICE
453  Vector& operator*=(const T& scalar)
454  {
455  for(size_t i = 0; i < dim; i++)
456  elems[i] *= scalar;
457  return *this;
458  }
459 
463  template <typename T1> CU_HOST_DEVICE Vector& operator*=(const T1& scalar)
464  {
465  for(size_t i = 0; i < dim; i++)
466  elems[i] = (T)(elems[i] * scalar);
467  return *this;
468  }
469 
473  CU_HOST_DEVICE
474  Vector& operator/=(const T& scalar)
475  {
476  for(size_t i = 0; i < dim; ++i)
477  elems[i] /= scalar;
478  return *this;
479  }
480 
484  template <typename T1> CU_HOST_DEVICE Vector& operator/=(const T1& scalar)
485  {
486  for(size_t i = 0; i < dim; ++i)
487  elems[i] = (T)(elems[i] / scalar);
488  return *this;
489  }
490 
494  CU_HOST_DEVICE
495  bool operator==(const Vector& vec) const
496  {
497  for(size_t i = 0; i < dim; i++)
498  if(elems[i] != vec.elems[i])
499  return false;
500 
501  return true;
502  }
503 
507  CU_HOST_DEVICE
508  bool operator!=(const Vector& vec) const {
509  return (!((*this) == vec));
510  }
511 
515  CU_HOST_DEVICE
516  T& operator[](size_t idx) {
517  return elems[idx];
518  }
519 
523  CU_HOST_DEVICE
524  const T& operator[](size_t idx) const {
525  return elems[idx];
526  }
527 
531  CU_HOST_DEVICE
532  T norm() const
533  {
534  #ifdef _MSC_VER
535  return std::sqrt((float)normsq()); // Incorrect, but stupid compiler can't compile correct code
536  #else
537  return std::sqrt(normsq());
538  #endif
539  }
540 
544  CU_HOST_DEVICE
545  T normsq() const
546  {
547  T ans = 0;
548  for(size_t i = 0; i < dim; i++)
549  ans += elems[i] * elems[i];
550 
551  return ans;
552  }
553 
557  CU_HOST_DEVICE
559  {
560  T sz = norm();
561  return ((*this) /= sz);
562  }
563 
567  CU_HOST_DEVICE
568  Vector normalized(void) const
569  {
570  Vector ans(*this);
571  return ans.normalize();
572  }
573 
574  bool iszero(void)
575  {
576  for(size_t i = 0; i < dim; i++)
577  if(elems[i] != 0)
578  return false;
579  return true;
580  }
581 
582  Vector& zero(void)
583  {
584  for(size_t i = 0; i < dim; i++)
585  elems[i] = 0;
586  return (*this);
587  }
588 
592  CU_HOST_DEVICE
593  void set(const T& x)
594  {
595  STATIC_ASSERT(dim == 1);
596  elems[0] = x;
597  }
598 
602  CU_HOST_DEVICE
603  void set(const T& x, const T& y)
604  {
605  STATIC_ASSERT(dim == 2);
606  elems[0] = x;
607  elems[1] = y;
608  }
609 
613  CU_HOST_DEVICE
614  void set(const T& x, const T& y, const T& z)
615  {
616  STATIC_ASSERT(dim == 3);
617  elems[0] = x;
618  elems[1] = y;
619  elems[2] = z;
620  }
621 
625  CU_HOST_DEVICE
626  void set(const T& x, const T& y, const T& z, const T& t)
627  {
628  STATIC_ASSERT(dim == 4);
629  elems[0] = x;
630  elems[1] = y;
631  elems[2] = z;
632  elems[3] = t;
633  }
634 
638  CU_HOST_DEVICE
639  Vector& operator=(const T& value)
640  {
641  for(size_t i = 0; i < dim; ++i) {
642  elems[i] = value;
643  }
644  return *this;
645  }
646 
650  CU_HOST_DEVICE
651  Vector cross(const Vector& other) const
652  {
653  STATIC_ASSERT(dim == 3);
654  return (*this) ^ other;
655  }
656 
660  CU_HOST_DEVICE
661  void x(const T& v)
662  {
663  STATIC_ASSERT(dim > 0);
664  elems[0] = v;
665  }
669  CU_HOST_DEVICE
670  void y(const T& v)
671  {
672  STATIC_ASSERT(dim > 1);
673  elems[1] = v;
674  }
678  CU_HOST_DEVICE
679  void z(const T& v)
680  {
681  STATIC_ASSERT(dim > 2);
682  elems[2] = v;
683  }
687  CU_HOST_DEVICE
688  void t(const T& v)
689  {
690  STATIC_ASSERT(dim > 3);
691  elems[3] = v;
692  }
696  CU_HOST_DEVICE
697  T& x()
698  {
699  STATIC_ASSERT(dim > 0);
700  return elems[0];
701  }
705  CU_HOST_DEVICE
706  T& y()
707  {
708  STATIC_ASSERT(dim > 1);
709  return elems[1];
710  }
714  CU_HOST_DEVICE
715  T& z()
716  {
717  STATIC_ASSERT(dim > 2);
718  return elems[2];
719  }
723  CU_HOST_DEVICE
724  T& t()
725  {
726  STATIC_ASSERT(dim > 3);
727  return elems[3];
728  }
732  CU_HOST_DEVICE
733  const T& x() const
734  {
735  STATIC_ASSERT(dim > 0);
736  return elems[0];
737  }
741  CU_HOST_DEVICE
742  const T& y() const
743  {
744  STATIC_ASSERT(dim > 1);
745  return elems[1];
746  }
750  CU_HOST_DEVICE
751  const T& z() const
752  {
753  STATIC_ASSERT(dim > 2);
754  return elems[2];
755  }
759  CU_HOST_DEVICE
760  const T& t() const
761  {
762  STATIC_ASSERT(dim > 3);
763  return elems[3];
764  }
765 
769  CU_HOST_DEVICE
770  void i(const T& v)
771  {
772  STATIC_ASSERT(dim > 0);
773  elems[0] = v;
774  }
778  CU_HOST_DEVICE
779  void j(const T& v)
780  {
781  STATIC_ASSERT(dim > 1);
782  elems[1] = v;
783  }
787  CU_HOST_DEVICE
788  void k(const T& v)
789  {
790  STATIC_ASSERT(dim > 2);
791  elems[2] = v;
792  }
796  CU_HOST_DEVICE
797  void l(const T& v)
798  {
799  STATIC_ASSERT(dim > 3);
800  elems[3] = v;
801  }
805  CU_HOST_DEVICE
806  T& i()
807  {
808  STATIC_ASSERT(dim > 0);
809  return elems[0];
810  }
814  CU_HOST_DEVICE
815  T& j()
816  {
817  STATIC_ASSERT(dim > 1);
818  return elems[1];
819  }
823  CU_HOST_DEVICE
824  T& k()
825  {
826  STATIC_ASSERT(dim > 2);
827  return elems[2];
828  }
832  CU_HOST_DEVICE
833  T& l()
834  {
835  STATIC_ASSERT(dim > 3);
836  return elems[3];
837  }
841  CU_HOST_DEVICE
842  const T& i() const
843  {
844  STATIC_ASSERT(dim > 0);
845  return elems[0];
846  }
850  CU_HOST_DEVICE
851  const T& j() const
852  {
853  STATIC_ASSERT(dim > 1);
854  return elems[1];
855  }
859  CU_HOST_DEVICE
860  const T& k() const
861  {
862  STATIC_ASSERT(dim > 2);
863  return elems[2];
864  }
868  CU_HOST_DEVICE
869  const T& l() const
870  {
871  STATIC_ASSERT(dim > 3);
872  return elems[3];
873  }
874 
878  CU_HOST_DEVICE
880  {
881  STATIC_ASSERT(dim > 1);
882  return Vector<2, T>(elems[0], elems[1]);
883  }
884 
890  CU_HOST_DEVICE
891  bool operator<(const Vector& other) const
892  {
893  for(size_t i = 0; i < dim; ++i) {
894  if(elems[i] < other.elems[i])
895  return true;
896  if(elems[i] > other.elems[i])
897  return false;
898  }
899  return false;
900  }
901 
907  CU_HOST_DEVICE
908  bool operator<=(const Vector& other) const
909  {
910  for(size_t i = 0; i < dim; ++i) {
911  if(elems[i] < other.elems[i])
912  return true;
913  if(elems[i] > other.elems[i])
914  return false;
915  }
916  return true;
917  }
918 
926  CU_HOST_DEVICE
927  bool operator>(const Vector& other) const
928  {
929  for(size_t i = 0; i < dim; ++i) {
930  if(elems[i] > other.elems[i])
931  return true;
932  if(elems[i] < other.elems[i])
933  return false;
934  }
935  return false;
936  }
937 
944  CU_HOST_DEVICE
945  bool operator>=(const Vector& other) const
946  {
947  for(size_t i = 0; i < dim; ++i) {
948  if(elems[i] > other.elems[i])
949  return true;
950  if(elems[i] < other.elems[i])
951  return false;
952  }
953  return true;
954  }
955 
956  friend std::ostream& operator<<(std::ostream& out, const Vector& vec)
957  {
958  for(size_t i = 0; i < dim; i++) {
959  out << vec.elems[i];
960  if(i != (dim - 1))
961  out << " ";
962  }
963  return out;
964  }
965 
966  friend std::istream& operator>>(std::istream& in, Vector& vec)
967  {
968  in >> vec[0];
969  for(size_t i = 1; i < dim && in; i++)
970  in >> std::ws >> vec[i];
971  return in;
972  }
973 
974  #ifndef COMPILE_CUDA
975  friend QTextStream& operator<<(QTextStream& out, const Vector& vec)
976  {
977  for(size_t i = 0; i < dim; i++) {
978  out << vec.elems[i];
979  if(i != (dim - 1))
980  out << " ";
981  }
982  return out;
983  }
984 
985  friend QTextStream& operator>>(QTextStream& in, Vector& vec)
986  {
987  in >> vec[0];
988  for(size_t i = 1; i < dim && !in.atEnd(); i++)
989  in >> ws >> vec[i];
990  return in;
991  }
992  #endif
993  };
994 
1000  template <class T> CU_HOST_DEVICE T operator%(const Vector<2, T>& v1, const Vector<2, T>& v2) {
1001  return v1 ^ v2;
1002  }
1003 
1009  template <class T>
1010  CU_HOST_DEVICE T
1011  operator^(const Vector<2, T>& v1, const Vector<2, T>& v2) {
1012  return ((v1[0] * v2[1]) - (v1[1] * v2[0]));
1013  }
1014 
1020  template <class T>
1021  CU_HOST_DEVICE T operator^(const Vector<1, T>&, const Vector<1, T>& ) {
1022  return 0;
1023  }
1024 
1030  template <class T>
1031  CU_HOST_DEVICE Vector<3, T> operator%(const Vector<3, T>& v1, const Vector<3, T>& v2)
1032  {
1033  return v1 ^ v2;
1034  }
1035 
1041  template <class T>
1042  CU_HOST_DEVICE Vector<3, T> operator^(const Vector<3, T>& v1, const Vector<3, T>& v2) {
1043  Vector<3, T> ans;
1044  ans[0] = v1[1] * v2[2] - v1[2] * v2[1];
1045  ans[1] = v1[2] * v2[0] - v1[0] * v2[2];
1046  ans[2] = v1[0] * v2[1] - v1[1] * v2[0];
1047  return ans;
1048  }
1049 
1055  template <class T>
1056  CU_HOST_DEVICE float angle(const Vector<2, T>& v)
1057  {
1058  return atan2(v.y(), v.x());
1059  }
1060 
1066  template <class T> CU_HOST_DEVICE float angle(const Vector<3, T>& v1, const Vector<3, T>& v2)
1067  {
1068  float x = v1 * v2;
1069  float y = norm(v1 ^ v2);
1070  return atan2(y, x);
1071  }
1072 
1078  template <class T> CU_HOST_DEVICE float angle(const Vector<2, T>& v1, const Vector<2, T>& v2)
1079  {
1080  float x = v1 * v2;
1081  float y = v1 ^ v2;
1082  return atan2(y, x);
1083  }
1084 
1090  template <class T> CU_HOST_DEVICE float angle(const Vector<1, T>& v1, const Vector<1, T>& v2)
1091  {
1092  return (v1 * v2 < 0) ? -1 : 1;
1093  }
1094 
1100  template <class T> CU_HOST_DEVICE float angle(const Vector<3, T>& v1, const Vector<3, T>& v2, const Vector<3, T>& ref)
1101  {
1102  float x = v1 * v2;
1103  Vector<3, T> n = v1 ^ v2;
1104  float y = norm(n);
1105  if(n * ref < 0)
1106  return atan2(-y, x);
1107  else
1108  return atan2(y, x);
1109  }
1110 
1118  CU_HOST_DEVICE
1119  float normalized(float) {
1120  return 1;
1121  }
1122 
1130  CU_HOST_DEVICE
1131  float normsq(float s) {
1132  return s * s;
1133  }
1134 
1142  CU_HOST_DEVICE
1143  float norm(float s) {
1144  return (s < 0) ? -s : s;
1145  }
1146 
1153  template <size_t dim, typename T> CU_HOST_DEVICE T norm(const Vector<dim, T>& v) {
1154  return v.norm();
1155  }
1156 
1163  template <size_t dim, typename T> CU_HOST_DEVICE T normsq(const Vector<dim, T>& v) {
1164  return v.normsq();
1165  }
1166 
1173  template <size_t dim, typename T> CU_HOST_DEVICE Vector<dim, T> normalized(const Vector<dim, T>& v)
1174  {
1175  return v.normalized();
1176  }
1177 
1178  using ::fabs;
1179 
1185  template <size_t dim, typename T> CU_HOST_DEVICE Vector<dim, T> fabs(const Vector<dim, T>& v)
1186  {
1187  Vector<dim, T> result;
1188  for(size_t i = 0; i < dim; ++i) {
1189  result[i] = fabs(v[i]);
1190  }
1191  return result;
1192  }
1193 
1200  template <size_t dim, typename T> CU_HOST_DEVICE Vector<dim, T> max(const Vector<dim, T>& v1, const Vector<dim, T>& v2)
1201  {
1202  Vector<dim, T> result;
1203  for(size_t i = 0; i < dim; ++i) {
1204  result[i] = (v1[i] >= v2[i] ? v1[i] : v2[i]);
1205  }
1206  return result;
1207  }
1208 
1215  template <size_t dim, typename T> CU_HOST_DEVICE Vector<dim, T> min(const Vector<dim, T>& v1, const Vector<dim, T>& v2)
1216  {
1217  Vector<dim, T> result;
1218  for(size_t i = 0; i < dim; ++i) {
1219  result[i] = (v1[i] <= v2[i] ? v1[i] : v2[i]);
1220  }
1221  return result;
1222  }
1223 
1229  template <size_t dim, typename T>
1230  CU_HOST_DEVICE Vector<dim, T> trim(const Vector<dim, T>& v, const Vector<dim, T>& minv, const Vector<dim, T>& maxv)
1231  {
1232  Vector<dim, T> result;
1233  result = max(minv, min(maxv, v));
1234  return result;
1235  }
1236 
1243  template <size_t dim, typename T>
1244  CU_HOST_DEVICE Vector<dim, T> multiply(const Vector<dim, T>& v1, const Vector<dim, T>& v2)
1245  {
1246  Vector<dim, T> result;
1247  for(size_t i = 0; i < dim; ++i) {
1248  result[i] = v1[i] * v2[i];
1249  }
1250  return result;
1251  }
1252 
1253  // /**
1254  // * Return the vector whose components are clipped to min/max
1255  // * components.
1256  // *
1257  // * \relates Vector
1258  // */
1259  // template <size_t dim, typename T>
1260  // CU_HOST_DEVICE
1261  // Vector<dim,T> multiply( const Vector<dim,T>& v, const Vector<dim,T>& minv, const Vector<dim,T>& maxv)
1262  // {
1263  // Vector<dim,T> result;
1264  // result = min(minv, max(maxv, v));
1265  // return result;
1266  // }
1267 
1274  template <size_t dim, typename T>
1275  CU_HOST_DEVICE Vector<dim, T> divide(const Vector<dim, T>& v1, const Vector<dim, T>& v2)
1276  {
1277  Vector<dim, T> result;
1278  for(size_t i = 0; i < dim; ++i) {
1279  result[i] = v1[i] / v2[i];
1280  }
1281  return result;
1282  }
1283 
1289  template <typename T> CU_HOST_DEVICE Vector<3, T> orthogonal(const Vector<3, T>& v)
1290  {
1291  const float ratio = 1 - 1e-8;
1292  if((std::abs(v.y()) >= ratio * std::abs(v.x())) && (std::abs(v.z()) >= ratio * std::abs(v.x())))
1293  return Vector<3, T>(0, -v.z(), v.y());
1294  else if((std::abs(v.x()) >= ratio * std::abs(v.y())) && (std::abs(v.z()) >= ratio * std::abs(v.y())))
1295  return Vector<3, T>(-v.z(), 0, v.x());
1296  else
1297  return Vector<3, T>(-v.y(), v.x(), 0);
1298  }
1299 
1300  /*
1301  * Transform all components of a vector with a function
1302  *
1303  * \relates Vector
1304  */
1305  template <size_t dim, typename T, typename T1>
1306  CU_HOST_DEVICE Vector<dim, T> map(const T& (*fct)(const T1 &), const Vector<dim, T1>& v)
1307  {
1308  Vector<dim, T> result;
1309  for(size_t i = 0; i < dim; ++i) {
1310  result[i] = (*fct)(v[i]);
1311  }
1312  return result;
1313  }
1314 
1315  /*
1316  * Transform all components of a vector with a function
1317  *
1318  * \relates Vector
1319  */
1320  template <size_t dim, typename T, typename T1>
1321  CU_HOST_DEVICE Vector<dim, T> map(T (*fct)(const T1&), const Vector<dim, T1>& v)
1322  {
1323  Vector<dim, T> result;
1324  for(size_t i = 0; i < dim; ++i) {
1325  result[i] = (*fct)(v[i]);
1326  }
1327  return result;
1328  }
1329 
1335  template <size_t dim, typename T, typename T1> CU_HOST_DEVICE Vector<dim, T> map(T (*fct)(T1), const Vector<dim, T1>& v)
1336  {
1337  Vector<dim, T> result;
1338  for(size_t i = 0; i < dim; ++i) {
1339  result[i] = (*fct)(v[i]);
1340  }
1341  return result;
1342  }
1343 
1349  template <size_t dim, typename T>
1350  CU_HOST_DEVICE Vector<dim, T> map(const T& (*fct)(const T &, const T &), const Vector<dim, T>& v1,
1351  const Vector<dim, T>& v2)
1352  {
1353  Vector<dim, T> result;
1354  for(size_t i = 0; i < dim; ++i) {
1355  result[i] = (*fct)(v1[i], v2[i]);
1356  }
1357  return result;
1358  }
1359 
1365  template <size_t dim, typename T>
1366  CU_HOST_DEVICE Vector<dim, T> map(T (*fct)(const T&, const T&), const Vector<dim, T>& v1, const Vector<dim, T>& v2)
1367  {
1368  Vector<dim, T> result;
1369  for(size_t i = 0; i < dim; ++i) {
1370  result[i] = (*fct)(v1[i], v2[i]);
1371  }
1372  return result;
1373  }
1374 
1380  template <size_t dim, typename T>
1381  CU_HOST_DEVICE Vector<dim, T> map(T (*fct)(T, T), const Vector<dim, T>& v1, const Vector<dim, T>& v2)
1382  {
1383  Vector<dim, T> result;
1384  for(size_t i = 0; i < dim; ++i) {
1385  result[i] = (*fct)(v1[i], v2[i]);
1386  }
1387  return result;
1388  }
1389 
1395  template <size_t dim, typename T, typename T1, typename T2>
1396  CU_HOST_DEVICE Vector<dim, T> map(const T& (*fct)(const T1 &, const T2 &), const Vector<dim, T1>& v1,
1397  const Vector<dim, T2>& v2)
1398  {
1399  Vector<dim, T> result;
1400  for(size_t i = 0; i < dim; ++i) {
1401  result[i] = (*fct)(v1[i], v2[i]);
1402  }
1403  return result;
1404  }
1405 
1411  template <size_t dim, typename T, typename T1, typename T2>
1412  CU_HOST_DEVICE Vector<dim, T> map(T (*fct)(const T1&, const T2&), const Vector<dim, T1>& v1, const Vector<dim, T2>& v2)
1413  {
1414  Vector<dim, T> result;
1415  for(size_t i = 0; i < dim; ++i) {
1416  result[i] = (*fct)(v1[i], v2[i]);
1417  }
1418  return result;
1419  }
1420 
1426  template <size_t dim, typename T, typename T1, typename T2>
1427  CU_HOST_DEVICE Vector<dim, T> map(T (*fct)(T1, T2), const Vector<dim, T1>& v1, const Vector<dim, T2>& v2)
1428  {
1429  Vector<dim, T> result;
1430  for(size_t i = 0; i < dim; ++i) {
1431  result[i] = (*fct)(v1[i], v2[i]);
1432  }
1433  return result;
1434  }
1435 
1441  template <size_t dim, typename T> CU_HOST_DEVICE Vector<dim, T> operator+(const Vector<dim, T>& v, const T& value)
1442  {
1443  Vector<dim, T> res;
1444  for(size_t i = 0; i < dim; ++i)
1445  res[i] = v[i] + value;
1446  return res;
1447  }
1448 
1454  template <size_t dim, typename T> CU_HOST_DEVICE Vector<dim, T> operator+(const T& value, const Vector<dim, T>& v)
1455  {
1456  Vector<dim, T> res;
1457  for(size_t i = 0; i < dim; ++i)
1458  res[i] = v[i] + value;
1459  return res;
1460  }
1461 
1467  template <size_t dim, typename T> CU_HOST_DEVICE Vector<dim, T> operator-(const Vector<dim, T>& v, const T& value)
1468  {
1469  Vector<dim, T> res;
1470  for(size_t i = 0; i < dim; ++i)
1471  res[i] = v[i] - value;
1472  return res;
1473  }
1474 
1481  template <size_t dim, typename T> CU_HOST_DEVICE Vector<dim, T> operator-(const T& value, const Vector<dim, T>& v)
1482  {
1483  Vector<dim, T> res;
1484  for(size_t i = 0; i < dim; ++i)
1485  res[i] = value - v[i];
1486  return res;
1487  }
1488 
1496  template <size_t dim, typename T> CU_HOST_DEVICE Vector<dim + 1, T> homogeneous(const Vector<dim, T>& v)
1497  {
1498  Vector<dim + 1, T> res(v);
1499  res[dim] = T(1);
1500  return res;
1501  }
1502 
1510  template <size_t dim, typename T> CU_HOST_DEVICE Vector<dim - 1, T> cartesian(const Vector<dim, T>& v)
1511  {
1512  Vector<dim - 1, T> res(v);
1513  res /= v[dim - 1];
1514  return res;
1515  }
1516 }}
1517 
1518 #ifndef COMPILE_CUDA
1519 // Add hashes for STL
1520  #include <UnorderedMap.hpp>
1521 
1522 namespace std {
1523 
1524  #ifdef HASH_NEED_TR1
1525  namespace tr1 {
1526  #endif
1527 
1528  template <size_t dim, typename T> struct hash<mgx::util::Vector<dim, T> > {
1529  size_t operator()(const mgx::util::Vector<dim, T>& v) const
1530  {
1531  static const hash<T> hash_value = hash<T>();
1532  size_t acc = hash_value(v[0]);
1533  for(size_t i = 1; i < dim; ++i)
1534  acc ^= hash_value(v[i]);
1535  return acc;
1536  }
1537  };
1538 
1539  # ifdef HASH_NEED_TR1
1540  }
1541  # endif
1542 }
1543 
1544 #endif
1545 
1546 #endif // VECTOR_H
CU_HOST_DEVICE Vector< dim, T > operator+(const Vector< dim, T > &v, const T &value)
Add a value to all elements of a vector.
Definition: Vector.hpp:1441
CU_HOST_DEVICE Vector(const T &x, const T &y, const T &z)
Initialize a 3D vector.
Definition: Vector.hpp:134
CU_HOST_DEVICE void t(const T &v)
Short access to the fourth element.
Definition: Vector.hpp:688
CU_HOST_DEVICE T operator^(const Vector< 2, T > &v1, const Vector< 2, T > &v2)
Cross product v1 x v2 (French notation)
Definition: Vector.hpp:1011
CU_HOST_DEVICE Vector< dim, T > map(T(*fct)(const T &, const T &), const Vector< dim, T > &v1, const Vector< dim, T > &v2)
Map a function to all elements of a vector.
Definition: Vector.hpp:1366
CU_HOST_DEVICE bool operator<=(const Vector &other) const
Comparison operator.
Definition: Vector.hpp:908
CU_HOST_DEVICE Vector & operator/=(const T1 &scalar)
In-place division by a scalar.
Definition: Vector.hpp:484
CU_HOST_DEVICE Vector(const T &a, const T &b, const T &c, const T &d, const T &e, const T &f, const T &g, const T &h, const T &i, const T &j, const T &k, const T &l)
Initialize a 12D vector.
Definition: Vector.hpp:204
CU_HOST_DEVICE Vector & operator/=(const T &scalar)
In-place division by a scalar.
Definition: Vector.hpp:474
CU_HOST_DEVICE Vector< 2, T > projectXY(void)
Extract the two first elements of the vector.
Definition: Vector.hpp:879
CU_HOST_DEVICE T & j()
Short access to the second element.
Definition: Vector.hpp:815
CU_HOST_DEVICE Vector cross(const Vector &other) const
Compute the cross product as this x other.
Definition: Vector.hpp:651
CU_HOST_DEVICE const T * c_data() const
Returns a constant raw pointer on the data.
Definition: Vector.hpp:272
CU_HOST_DEVICE float angle(const Vector< 3, T > &v1, const Vector< 3, T > &v2, const Vector< 3, T > &ref)
Oriented angle between v1 and v2 with ref to orient the space.
Definition: Vector.hpp:1100
CU_HOST_DEVICE Vector< dim, T > divide(const Vector< dim, T > &v1, const Vector< dim, T > &v2)
Return the vector whose components are clipped to min/max components.
Definition: Vector.hpp:1275
CU_HOST_DEVICE Vector normalized(void) const
Returns a normalized version of the vector.
Definition: Vector.hpp:568
CU_HOST_DEVICE T & y()
Short access to the second element.
Definition: Vector.hpp:706
CU_HOST_DEVICE const T & operator[](size_t idx) const
Access to the element idx.
Definition: Vector.hpp:524
CU_HOST_DEVICE const T & l() const
Short access to the fourth element.
Definition: Vector.hpp:869
CU_HOST_DEVICE const T & j() const
Short access to the second element.
Definition: Vector.hpp:851
CU_HOST_DEVICE T & t()
Short access to the fourth element.
Definition: Vector.hpp:724
CU_HOST_DEVICE T norm() const
Euclidean norm of the vector.
Definition: Vector.hpp:532
CU_HOST_DEVICE float angle(const Vector< 2, T > &v1, const Vector< 2, T > &v2)
Oriented angle between v1 and v2.
Definition: Vector.hpp:1078
CU_HOST_DEVICE void x(const T &v)
Short access to the first element.
Definition: Vector.hpp:661
CU_HOST_DEVICE Vector(const T &x, const T &y, const T &z, const T &a, const T &b, const T &c)
Initialize a 6D vector.
Definition: Vector.hpp:173
STL namespace.
CU_HOST_DEVICE Vector & normalize(void)
Normalize the vector.
Definition: Vector.hpp:558
CU_HOST_DEVICE Vector(const Vector< d1, T1 > &vec)
Copy another vector with different number of elements.
Definition: Vector.hpp:82
CU_HOST_DEVICE Vector operator-(void) const
Vector negation.
Definition: Vector.hpp:280
CU_HOST_DEVICE T & i()
Short access to the first element.
Definition: Vector.hpp:806
CU_HOST_DEVICE Vector< dim, T > fabs(const Vector< dim, T > &v)
Return the vector whose component is the absolute value of the input vector.
Definition: Vector.hpp:1185
CU_HOST_DEVICE float normalized(float)
Euclidean square norm of a real.
Definition: Vector.hpp:1119
CU_HOST_DEVICE Vector operator*(const T &scalar) const
Multiplication by a scalar.
Definition: Vector.hpp:327
CU_HOST_DEVICE Vector & operator*=(const T &scalar)
In-place multiplication by a scalar.
Definition: Vector.hpp:453
CU_HOST_DEVICE Vector< dim-1, T > cartesian(const Vector< dim, T > &v)
Extract the cartesion coordinates from a homogeneous vector.
Definition: Vector.hpp:1510
CU_HOST_DEVICE T norm(const Vector< dim, T > &v)
Function-version of the norm.
Definition: Vector.hpp:1153
CU_HOST_DEVICE Vector(const T &x, const T &y)
Initialize a 2D vector.
Definition: Vector.hpp:123
CU_HOST_DEVICE T operator%(const Vector< 2, T > &v1, const Vector< 2, T > &v2)
Cross product v1 x v2.
Definition: Vector.hpp:1000
CU_HOST_DEVICE Vector(const T &x, const T &y, const T &z, const T &a, const T &b)
Initialize a 5D vector.
Definition: Vector.hpp:159
CU_HOST_DEVICE Vector< dim, T > multiply(const Vector< dim, T > &v1, const Vector< dim, T > &v2)
Return the vector whose component is the product of the two input vectors components.
Definition: Vector.hpp:1244
CU_HOST_DEVICE Vector(const Vector &vec)
Copy another vector.
Definition: Vector.hpp:64
CU_HOST_DEVICE const T & x() const
Short access to the first element.
Definition: Vector.hpp:733
CU_HOST_DEVICE Vector operator-(const Vector &vec) const
Vector subtraction.
Definition: Vector.hpp:304
CU_HOST_DEVICE T & x()
Short access to the first element.
Definition: Vector.hpp:697
CU_HOST_DEVICE bool operator==(const Vector &vec) const
Element-wise equality.
Definition: Vector.hpp:495
CU_HOST_DEVICE Vector & operator+=(const Vector &vec)
In-place vector addition.
Definition: Vector.hpp:409
CU_HOST_DEVICE T & operator[](size_t idx)
Access to the element idx.
Definition: Vector.hpp:516
CU_HOST_DEVICE Vector & operator-=(const T &val)
In-place value subtraction.
Definition: Vector.hpp:442
CU_HOST_DEVICE Vector< dim, T > map(T(*fct)(T1), const Vector< dim, T1 > &v)
Map a function to all elements of a vector.
Definition: Vector.hpp:1335
CU_HOST_DEVICE Vector(const Vec &el)
Initialize a vector from any object behaving like an array.
Definition: Vector.hpp:103
CU_HOST_DEVICE iterator end()
STL-iteration end.
Definition: Vector.hpp:257
CU_HOST_DEVICE Vector< 3, T > operator%(const Vector< 3, T > &v1, const Vector< 3, T > &v2)
Cross product v1 x v2.
Definition: Vector.hpp:1031
CU_HOST_DEVICE Vector & operator+=(const T &val)
In-place constant addition.
Definition: Vector.hpp:420
CU_HOST_DEVICE const_iterator end() const
Stl-iteration constant end.
Definition: Vector.hpp:264
CU_HOST_DEVICE iterator begin()
STL-iteration begin.
Definition: Vector.hpp:242
CU_HOST_DEVICE Vector mult(const Vector &vec) const
Element-wise multiplcation.
Definition: Vector.hpp:315
CU_HOST_DEVICE bool operator>=(const Vector &other) const
Comparison operator.
Definition: Vector.hpp:945
CU_HOST_DEVICE Vector & operator*=(const T1 &scalar)
In-place multiplication by a scalar.
Definition: Vector.hpp:463
CU_HOST_DEVICE T * data()
Returns a raw pointer on the data.
Definition: Vector.hpp:234
CU_HOST_DEVICE float angle(const Vector< 1, T > &v1, const Vector< 1, T > &v2)
Oriented angle between v1 and v2.
Definition: Vector.hpp:1090
CU_HOST_DEVICE void y(const T &v)
Short access to the second element.
Definition: Vector.hpp:670
CU_HOST_DEVICE Vector & operator/=(const Vector &vec)
In-place element-wise division by a scalar.
Definition: Vector.hpp:360
CU_HOST_DEVICE float normsq(float s)
Euclidean square norm of a real.
Definition: Vector.hpp:1131
This namespace contains all the API of MorphoGraphX.
Definition: Assert.hpp:26
CU_HOST_DEVICE Vector< dim, T > min(const Vector< dim, T > &v1, const Vector< dim, T > &v2)
Return the vector whose component is the min of the two input vectors components. ...
Definition: Vector.hpp:1215
CU_HOST_DEVICE Vector< dim, T > normalized(const Vector< dim, T > &v)
Function-version of the square norm.
Definition: Vector.hpp:1173
CU_HOST_DEVICE Vector(const T &x, const T &y, const T &z, const T &a, const T &b, const T &c, const T &d)
Initialize a 7D vector.
Definition: Vector.hpp:188
Namespace containing all the utility classes.
Definition: Vector.hpp:47
CU_HOST_DEVICE void i(const T &v)
Short access to the first element.
Definition: Vector.hpp:770
CU_HOST_DEVICE Vector operator/(const T &scalar) const
Division by a scalar.
Definition: Vector.hpp:338
CU_HOST_DEVICE Vector(const T &x, const T &y, const T &z, const T &t)
Initialize a 4D vector.
Definition: Vector.hpp:146
CU_HOST_DEVICE Vector< dim, T > map(T(*fct)(T1, T2), const Vector< dim, T1 > &v1, const Vector< dim, T2 > &v2)
Map a function to all elements of a vector.
Definition: Vector.hpp:1427
#define STATIC_ASSERT(B)
Assertion that works at compile time.
Definition: StaticAssert.hpp:57
CU_HOST_DEVICE bool operator<(const Vector &other) const
Comparison operator.
Definition: Vector.hpp:891
CU_HOST_DEVICE Vector & operator-=(const Vector &vec)
In-place vector subtraction.
Definition: Vector.hpp:431
CU_HOST_DEVICE T normsq(const Vector< dim, T > &v)
Function-version of the square norm.
Definition: Vector.hpp:1163
static CU_HOST_DEVICE size_t size()
Returns the size of the vector (i.e.
Definition: Vector.hpp:226
CU_HOST_DEVICE const T & z() const
Short access to the third element.
Definition: Vector.hpp:751
CU_HOST_DEVICE Vector operator/(const Vector &vec) const
Element-wise division.
Definition: Vector.hpp:349
CU_HOST_DEVICE T normsq() const
Square of the Euclidean norm of the vector.
Definition: Vector.hpp:545
CU_HOST_DEVICE Vector< dim, T > trim(const Vector< dim, T > &v, const Vector< dim, T > &minv, const Vector< dim, T > &maxv)
Return the vector with components clipped to min and max vectors.
Definition: Vector.hpp:1230
Define the STATIC_ASSERT macro.
CU_HOST_DEVICE T & z()
Short access to the third element.
Definition: Vector.hpp:715
CU_HOST_DEVICE float norm(float s)
Euclidean norm of a real.
Definition: Vector.hpp:1143
CU_HOST_DEVICE T & l()
Short access to the fourth element.
Definition: Vector.hpp:833
CU_HOST_DEVICE friend Vector operator*(const T &scalar, const Vector &vec)
Multiplication by a scalar.
Definition: Vector.hpp:371
CU_HOST_DEVICE void l(const T &v)
Short access to the fourth element.
Definition: Vector.hpp:797
CU_HOST_DEVICE const T & t() const
Short access to the fourth element.
Definition: Vector.hpp:760
CU_HOST_DEVICE void z(const T &v)
Short access to the third element.
Definition: Vector.hpp:679
CU_HOST_DEVICE Vector< dim, T > map(T(*fct)(const T1 &, const T2 &), const Vector< dim, T1 > &v1, const Vector< dim, T2 > &v2)
Map a function to all elements of a vector.
Definition: Vector.hpp:1412
CU_HOST_DEVICE Vector< dim, T > operator-(const Vector< dim, T > &v, const T &value)
Substact a value to all elements of a vector.
Definition: Vector.hpp:1467
CU_HOST_DEVICE void k(const T &v)
Short access to the third element.
Definition: Vector.hpp:788
CU_HOST_DEVICE Vector< 3, T > operator^(const Vector< 3, T > &v1, const Vector< 3, T > &v2)
Cross product v1 x v2 (French notation)
Definition: Vector.hpp:1042
CU_HOST_DEVICE bool operator>(const Vector &other) const
Comparison operator.
Definition: Vector.hpp:927
CU_HOST_DEVICE Vector< dim, T > map(const T &(*fct)(const T1 &, const T2 &), const Vector< dim, T1 > &v1, const Vector< dim, T2 > &v2)
Map a function to all elements of a vector.
Definition: Vector.hpp:1396
CU_HOST_DEVICE Vector operator+(const Vector &vec) const
Vector addition.
Definition: Vector.hpp:293
CU_HOST_DEVICE T operator*(const Vector &vec) const
Dot product.
Definition: Vector.hpp:384
CU_HOST_DEVICE Vector< dim+1, T > homogeneous(const Vector< dim, T > &v)
Create a homogeneous coordinate vector from a cartesian one.
Definition: Vector.hpp:1496
CU_HOST_DEVICE Vector< dim, T > max(const Vector< dim, T > &v1, const Vector< dim, T > &v2)
Return the vector whose component is the max of the two input vectors components. ...
Definition: Vector.hpp:1200
CU_HOST_DEVICE float angle(const Vector< 2, T > &v)
Angle of the vector with (0,1)
Definition: Vector.hpp:1056
CU_HOST_DEVICE Vector & operator=(const T &value)
Set all the elements to value.
Definition: Vector.hpp:639
CU_HOST_DEVICE T operator^(const Vector< 1, T > &, const Vector< 1, T > &)
Cross product v1 x v2 (French notation)
Definition: Vector.hpp:1021
CU_HOST_DEVICE float angle(const Vector< 3, T > &v1, const Vector< 3, T > &v2)
Non-oriented angle between v1 and v2.
Definition: Vector.hpp:1066
CU_HOST_DEVICE Vector< dim, T > operator-(const T &value, const Vector< dim, T > &v)
Equivalent to substracting a vector with all component the same to another one.
Definition: Vector.hpp:1481
CU_HOST_DEVICE Vector< dim, T > map(T(*fct)(T, T), const Vector< dim, T > &v1, const Vector< dim, T > &v2)
Map a function to all elements of a vector.
Definition: Vector.hpp:1381
CU_HOST_DEVICE T & k()
Short access to the third element.
Definition: Vector.hpp:824
CU_HOST_DEVICE Vector(const Vector< dim, T1 > &vec)
Copy another vector with different number of elements.
Definition: Vector.hpp:73
CU_HOST_DEVICE const T & y() const
Short access to the second element.
Definition: Vector.hpp:742
CU_HOST_DEVICE const_iterator begin() const
Stl-iteration constant begin.
Definition: Vector.hpp:249
CU_HOST_DEVICE const T & k() const
Short access to the third element.
Definition: Vector.hpp:860
CU_HOST_DEVICE Vector< 3, T > orthogonal(const Vector< 3, T > &v)
Find a vector orthogonal to v.
Definition: Vector.hpp:1289
CU_HOST_DEVICE bool operator!=(const Vector &vec) const
Element-wise inequality.
Definition: Vector.hpp:508
CU_HOST_DEVICE void j(const T &v)
Short access to the second element.
Definition: Vector.hpp:779
CU_HOST_DEVICE Vector< dim, T > map(const T &(*fct)(const T &, const T &), const Vector< dim, T > &v1, const Vector< dim, T > &v2)
Map a function to all elements of a vector.
Definition: Vector.hpp:1350
CU_HOST_DEVICE Vector & operator=(const Vector &vec)
Vector copy.
Definition: Vector.hpp:397
CU_HOST_DEVICE Vector(const T &x=T())
Initialize a vector with all values to x.
Definition: Vector.hpp:113
CU_HOST_DEVICE const T & i() const
Short access to the first element.
Definition: Vector.hpp:842
CU_HOST_DEVICE Vector< dim, T > operator+(const T &value, const Vector< dim, T > &v)
Add a value to all elements of a vector.
Definition: Vector.hpp:1454