KJB
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
m_vector_d.h
Go to the documentation of this file.
1 /* $Id: m_vector_d.h 18367 2014-12-08 18:29:27Z ksimek $ */
2 /* {{{=========================================================================== *
3  |
4  | Copyright (c) 1994-2011 by Kobus Barnard (author)
5  |
6  | Personal and educational use of this code is granted, provided that this
7  | header is kept intact, and that the authorship is not misrepresented, that
8  | its use is acknowledged in publications, and relevant papers are cited.
9  |
10  | For other use contact the author (kobus AT cs DOT arizona DOT edu).
11  |
12  | Please note that the code in this file has not necessarily been adequately
13  | tested. Naturally, there is no guarantee of performance, support, or fitness
14  | for any particular task. Nonetheless, I am interested in hearing about
15  | problems that you encounter.
16  |
17  | Author: Kyle Simek
18  * =========================================================================== }}}*/
19 
20 // vim: tabstop=4 shiftwidth=4 foldmethod=marker
21 
22 #ifndef KJB_M_VECTOR_D_H
23 #define KJB_M_VECTOR_D_H
24 
25 #include <boost/array.hpp>
26 #include <algorithm>
27 //#include <iterator>
28 
29 #ifdef KJB_HAVE_BST_SERIAL
30 #include <boost/serialization/access.hpp>
31 #endif
32 
45 namespace kjb
46 {
47 
48 class Vector;
49 class Matrix;
55 template<std::size_t D>
56 class Vector_d : public boost::array<double, D>
57 {
58  typedef typename boost::array<double, D> Base;
59 
60 #ifdef KJB_HAVE_BST_SERIAL
61  friend class boost::serialization::access;
62 #endif
63 
64 public:
65  using typename Base::value_type;
66  using typename Base::difference_type;
67  using typename Base::size_type;
68  using typename Base::reference;
69  using typename Base::const_reference;
70  using typename Base::iterator;
71  using typename Base::const_iterator;
73  Vector_d();
74 
76  Vector_d(const Vector_d& v);
77 
79  Vector_d(const Vector_d<D-1>& v, double fill1);
80 
81 
83  Vector_d(const Vector_d<D-1>& v, double fill1, double fill2);
84 
85 
87  template <class Iterator>
88  explicit Vector_d(Iterator begin) :
89  Base()
90  {
91  Iterator end = begin;
92  std::advance(end, D);
93  std::copy(begin, end, this->begin());
94  }
95 
97  explicit Vector_d(const Vector& v);
98 
99 
101  explicit Vector_d(double init);
102 
103  Vector_d(double x, double y);
104 
108  Vector_d(double x, double y, double z);
109 
113  Vector_d( double x, double y, double z, double w);
114 
119  double x() const;
120 
125  double& x();
126 
127  void set_x(double xv) ;
128 
133  double y() const ;
134 
139  double& y();
140 
142  void set_y(double yv) ;
143 
147  double z() const ;
148 
153  double& z();
154 
156  void set_z(double zv) ;
157 
163  double w() const;
164 
169  double& w();
170 
172  void set_w(double wv);
173 
174 
176  Vector_d& operator=(const Vector_d& other);
177 
179  Vector_d& operator=(const Vector& other);
180 
181 
182  Vector_d<D>& operator-=(const Vector_d<D>& second);
183  Vector_d<D>& operator-=(double second);
184 
185  Vector_d<D>& operator+=(const Vector_d<D>& second);
186  Vector_d<D>& operator+=(double second);
187 
188  Vector_d<D>& operator*=(double s);
189 
190  Vector_d<D>& operator/=(double s);
191 
193  void resize(size_t n);
194 
195  double norm1() const;
196 
198  double magnitude_squared() const;
199 
201  double magnitude() const;
202 
205 
207  Vector_d<D> normalized() const;
208 
209  Vector_d<D>& negate();
210 
211 #ifdef KJB_HAVE_BST_SERIAL
212  template <class Archive>
213  void serialize(Archive &ar, const unsigned int /* version */);
214 #endif
215 };
216 
217 // TYPEDEFS
218 typedef Vector_d<2> Vector2;
219 typedef Vector_d<3> Vector3;
220 typedef Vector_d<4> Vector4;
221 
222 
223 
225 template <std::size_t D>
226 Vector operator*(const Matrix& m, const Vector_d<D> v);
227 
229 Vector multiply_matrix_and_vector_d_dispatch_(const Matrix& m, const double* v, size_t size);
230 
231 
232 
233 #if 0
234 // Static matrix not implemented yet
236 template <std::size_t D_out, std::size_t D_in>
237 Vector_d<D_out> operator*(const Matrix_d<D_out, D_in>& m, const Vector_d<D_in> v)
238 {
239  Vector_d<D_out> result();
240 
241  for (int row = 0; row < D_out; row++)
242  {
243  double x = 0;
244 
245  for (size_t col = 0; col < D_in; col++)
246  {
247  x += m(row, col) * v[col];
248  }
249 
250  result[row] = x;
251  }
252 
253  return result;
254 }
255 #endif
256 
257 //
259 //Vector operator*(const Vector_d<D> v, const Matrix& m)
260 //{
261 // return m.transpose() * v;
262 //}
263 
264 template <std::size_t D>
265 Vector_d<D> operator-(const Vector_d<D>& first, const Vector_d<D>& second);
266 
267 template <std::size_t D>
268 Vector_d<D> operator-(const Vector_d<D>& first, double second);
269 
270 template <std::size_t D>
271 Vector_d<D> operator-(double first, const Vector_d<D>& second);
272 
273 template <std::size_t D>
274 Vector_d<D> operator-(const Vector_d<D>& first );
275 
276 template <std::size_t D>
277 Vector_d<D> operator+(const Vector_d<D>& first, const Vector_d<D>& second);
278 
279 template <std::size_t D>
280 Vector_d<D> operator+(const Vector_d<D>& first, double second);
281 
282 template <std::size_t D>
283 Vector_d<D> operator+(double first, const Vector_d<D>& second);
284 
285 template <std::size_t D>
286 Vector_d<D> operator*(const Vector_d<D>& v, double s);
287 
288 template <std::size_t D>
289 Vector_d<D> operator*(double s, const Vector_d<D>& v);
290 
291 template <std::size_t D>
292 Vector_d<D> operator/(const Vector_d<D>& v, double s);
293 
294 template<std::size_t N>
295 void swap(Vector_d<N>& first, Vector_d<N>& second);
296 
297 // COMPARATORS
298 template<std::size_t N>
299 bool operator==(const Vector_d<N>& first, const Vector_d<N>& second);
300 
301 template<std::size_t N>
302 bool operator!=(const Vector_d<N>& first, const Vector_d<N>& second);
303 
304 template<std::size_t N>
305 bool operator<(const Vector_d<N>& first, const Vector_d<N>& second);
306 
307 template<std::size_t N>
308 bool operator>(const Vector_d<N>& first, const Vector_d<N>& second);
309 
310 template<std::size_t N>
311 bool operator<=(const Vector_d<N>& first, const Vector_d<N>& second);
312 
313 template<std::size_t N>
314 bool operator>=(const Vector_d<N>& first, const Vector_d<N>& second);
315 
316 // TYPEDEFS
317 typedef Vector_d<2> Vector2;
318 typedef Vector_d<3> Vector3;
319 typedef Vector_d<4> Vector4;
320 
321 // MATH FUNCTIONS
322 template <size_t D>
323 double norm1(const kjb::Vector_d<D>& v);
324 
325 template <size_t D>
326 double norm2(const kjb::Vector_d<D>& v);
327 
328 
329 // UTILITY FUNCTIONS
330 template <size_t D>
331 Vector_d<D> create_random_vector();
332 
333 template <size_t D>
334 Vector_d<D> create_gauss_random_vector();
335 
337 {
338  return create_random_vector<2>();
339 }
340 
342 {
343  return create_random_vector<3>();
344 }
345 
347 {
348  return create_random_vector<4>();
349 }
350 
351 template <size_t D>
352 Vector_d<D> create_unit_vector(size_t d);
353 
355 Vector2 make_vector2(const Vector& v);
356 
358 Vector3 make_vector3(const Vector& v);
359 
361 Vector4 make_vector4(const Vector& v);
362 
363 
364 template <std::size_t D>
365 std::ostream& operator<<(std::ostream& out, const Vector_d<D>& v);
366 
367 template <std::size_t D>
368 std::istream& operator>>(std::istream& ist, Vector_d<D>& v);
369 
370 template <std::size_t D>
371 double dot(const Vector_d<D>& op1, const Vector_d<D>& op2);
372 
378 template <std::size_t D>
379 double vector_distance(const Vector_d<D>& op1, const Vector_d<D>& op2);
380 
381 template <std::size_t D>
382 double vector_distance_squared(const Vector_d<D>& op1, const Vector_d<D>& op2);
383 
387 inline Vector3 cross(const Vector3& op1, const Vector3& op2)
388 {
389  Vector3 out;
390  out[0] = op1[1] * op2[2] - op1[2] * op2[1];
391  out[1] = op1[2] * op2[0] - op1[0] * op2[2];
392  out[2] = op1[0] * op2[1] - op1[1] * op2[0];
393  return out;
394 }
395 
396 
399 } // namespace kjb
400 
401 #endif
402 
Vector_d()
default constructor
Definition: m_vector_d.impl.h:46
void set_z(double zv)
Changes the third element of a vector (if it exists).
Definition: m_vector_d.impl.h:230
double vector_distance(const Int_vector &op1, const Int_vector &op2)
Compute the Euclidian distance between two vectors.
Definition: l_int_vector.h:1569
Int_vector cross(const Int_vector &op1, const Int_vector &op2)
Compute cross product of op1 and op2.
Definition: l_int_vector.cpp:381
Vector_d< 4 > Vector4
Definition: gr_opengl.h:38
double magnitude() const
return the l2-norm of this vector
Definition: m_vector_d.impl.h:369
double vector_distance_squared(const Int_vector &op1, const Int_vector &op2)
Compute the square of the Euclidian distance between two vectors.
Definition: l_int_vector.h:1581
Vector create_random_vector(int length)
Construct a vector with values drawn from a uniform distribution over [0,1].
Definition: m_vector.h:1643
Vector_d< 3 > Vector3
Definition: g_quaternion.h:37
void set_x(double xv)
Definition: m_vector_d.impl.h:159
Vector_d< D > & operator/=(double s)
Definition: m_vector_d.impl.h:332
void swap(Perspective_camera &cam1, Perspective_camera &cam2)
Swap two cameras.
Definition: perspective_camera.h:599
double y() const
Definition: m_vector_d.impl.h:169
Vector4 create_random_vector4()
Definition: m_vector_d.h:346
double z() const
Definition: m_vector_d.impl.h:205
Vector_d< D > normalized() const
Non-mutating (functionally pure) version of normalize()
Definition: m_vector_d.impl.h:384
Vector2 create_random_vector2()
Definition: m_vector_d.h:336
Image operator-(const Image &im1, const Image &im2)
Subtract two images.
Definition: i_image.h:843
This class implements vectors, in the linear-algebra sense, with real-valued elements.
Definition: m_vector.h:87
void set_w(double wv)
Changes the fourth element of a vector (if it exists).
Definition: m_vector_d.impl.h:262
bool operator>=(const Int_vector &op1, const Int_vector &op2)
Test lexicographic ordering between vectors.
Definition: l_int_vector.h:1494
Vector_d< D > & operator*=(double s)
Definition: m_vector_d.impl.h:321
std::istream & operator>>(std::istream &ist, Detection_type &type)
Stream in an detection.
Definition: d_type.cpp:91
void resize(size_t n)
Definition: m_vector_d.impl.h:339
Image operator+(const Image &op1, const Image &op2)
Add two images.
Definition: i_image.h:834
double x() const
Definition: m_vector_d.impl.h:134
Vector2 make_vector2(const Vector &v)
Definition: m_vector_d.cpp:121
Vector3 make_vector3(const Vector &v)
Definition: m_vector_d.cpp:128
Vector_d< D > & operator-=(const Vector_d< D > &second)
Definition: m_vector_d.impl.h:289
Vector4 make_vector4(const Vector &v)
Definition: m_vector_d.cpp:135
double w() const
read fourth element (i.e., index 3) of vector, if it exists.
Definition: m_vector_d.impl.h:241
Vector_d< D > & operator+=(const Vector_d< D > &second)
Definition: m_vector_d.impl.h:305
x
Definition: APPgetLargeConnectedEdges.m:100
Vector_d< D > & normalize()
normalize this vector to have l2-norm of 1.0
Definition: m_vector_d.impl.h:376
bool operator>(const Int_vector &op1, const Int_vector &op2)
Test lexicographic ordering between vectors.
Definition: l_int_vector.h:1485
double norm1() const
Definition: m_vector_d.impl.h:348
Image operator/(const Image &op1, double op2)
Scale an image in channel space, yielding a new image.
Definition: i_image.h:825
Vector multiply_matrix_and_vector_d_dispatch_(const Matrix &m, const double *v, size_t size)
dispatch for operator*(Matrix, Vector_d). This deals with a circular dependency between matrix...
Definition: m_vector_d.cpp:97
bool operator!=(const Int_matrix &op1, const Int_matrix::Impl_type &op2)
Test for any difference between two matrices.
Definition: l_int_matrix.h:1274
Vector_d & operator=(const Vector_d &other)
assignment
Definition: m_vector_d.impl.h:267
bool operator==(const Int_matrix &op1, const Int_matrix::Impl_type &op2)
Test for exact equality between two matrices.
Definition: l_int_matrix.cpp:218
Vector create_gauss_random_vector(int length)
Construct a vector with values drawn from a standard Gaussian distribution (mean 0, variance 1);.
Definition: m_vector.cpp:390
Vector3 create_random_vector3()
Definition: m_vector_d.h:341
double norm1(const Vector &op)
Compute L1-norm of vector.
Definition: m_vector.h:2020
Vector_d< D > create_unit_vector(size_t d)
Definition: m_vector_d.impl.h:606
Definition: g_quaternion.h:37
double norm2(const Int_vector &op1)
Compute l2-norm of vector.
Definition: l_int_vector.h:1558
Vector_d(Iterator begin)
Fill constructor.
Definition: m_vector_d.h:88
void set_y(double yv)
Changes the second element of a vector (if it exists).
Definition: m_vector_d.impl.h:196
long int dot(const Int_vector &op1, const Int_vector &op2)
Returns dot product of this and op2.
Definition: l_int_vector.h:1532
for m
Definition: APPgetLargeConnectedEdges.m:64
D
Definition: APPgetLargeConnectedEdges.m:106
Vector_d< D > & negate()
Definition: m_vector_d.impl.h:390
Vector_d< 2 > Vector2
Definition: gr_opengl.h:35
Gsl_Vector operator*(double scalar, const Gsl_Vector &vector)
multiply scalar and vector, scalar written on the left side
Definition: gsl_vector.h:661
double magnitude_squared() const
return the squared l2-norm of this vector
Definition: m_vector_d.impl.h:362