From e65084dd0b86169a9c2a34b95742ba173c8da4f0 Mon Sep 17 00:00:00 2001 From: Yann Herklotz Date: Fri, 28 Jul 2017 00:30:52 +0100 Subject: Updating docs --- matrix_8hpp_source.html | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'matrix_8hpp_source.html') diff --git a/matrix_8hpp_source.html b/matrix_8hpp_source.html index ff189d16..af613af6 100644 --- a/matrix_8hpp_source.html +++ b/matrix_8hpp_source.html @@ -67,10 +67,10 @@ $(function() {
matrix.hpp
-Go to the documentation of this file.
1 /* ----------------------------------------------------------------------------
2  * matrix.hpp
3  *
4  * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
5  * See file LICENSE for more details
6  * ----------------------------------------------------------------------------
7  */
8 
16 #ifndef YAGE_MATH_MATRIX_HPP
17 #define YAGE_MATH_MATRIX_HPP
18 
19 #include <algorithm>
20 #include <exception>
21 #include <iostream>
22 #include <sstream>
23 #include <string>
24 #include <vector>
25 
26 namespace yage
27 {
28 
29 template<int Rows, int Cols, class Type> class Matrix;
30 
31 // includes implementation details that should not be accessible to the user
32 namespace detail
33 {
34 
35 // Row class
36 //
37 // Used to implement the double square bracket operator and be able
38 // to return the value by reference of the array.
39 template<int Rows, int Cols, class Type> class Row
40 {
41 private:
42  Matrix<Rows, Cols, Type> *parent_;
43  int index_;
44 
45 public:
46  Row<Rows, Cols, Type>(Matrix<Rows, Cols, Type> *parent, int index) :
47  parent_(parent), index_(index)
48  {}
49 
50  Type& operator[](int col)
51  {
52  // the index is the y-position of the element in the matrix
53  return parent_->data_[index_*Cols+col];
54  }
55 
56  const Type& operator[](int col) const
57  {
58  return parent_->data_[index_*Cols+col];
59  }
60 };
61 
62 } // detail
63 
64 // Matrix class
65 //
66 // Implements the base Matrix class that is inherited by other classes to make them more
67 // specific.
68 template<int Rows=4, int Cols=4, class Type=double> class Matrix
69 {
70  // friended with the row class so that it can access protected member data
71  friend class detail::Row<Rows, Cols, Type>;
72 protected:
73  std::vector<Type> data_;
74 
75 public:
76  Matrix<Rows, Cols, Type>() : data_(Rows*Cols) {}
77 
78  int rowSize() const
79  {
80  return Rows;
81  }
82 
83  int colSize() const
84  {
85  return Cols;
86  }
87 
88  // returns the row in a row matrix
89  Matrix<1, Cols, Type> getRow(int row) const
90  {
91  Matrix<1, Cols, Type> rowMatrix;
92  for(int i=0; i<Cols; ++i)
93  {
94  rowMatrix[0][i]=data_[row][i];
95  }
96  return rowMatrix;
97  }
98 
99  // returns the column in a column matrix
100  Matrix<Rows, 1, Type> getCol(int col) const
101  {
102  Matrix<Rows, 1, Type> colMatrix;
103  for(int i=0; i<Rows; ++i)
104  {
105  colMatrix[i][0]=data_[i][col];
106  }
107  return colMatrix;
108  }
109 
110  // iterator support for begin
111  typename std::vector<Type>::iterator begin()
112  {
113  return data_.begin();
114  }
115 
116  // iterator support for end
117  typename std::vector<Type>::iterator end()
118  {
119  return data_.end();
120  }
121 
122  // prints out the matrix, but can also be implemented by other classes to print data
123  // differently
124  virtual std::string toString() const
125  {
126  std::stringstream ss;
127  ss<<'[';
128  for(int i=0; i<Rows-1; ++i)
129  {
130  ss<<'[';
131  for(int j=0; j<Cols-1; ++j)
132  {
133  ss<<data_[i*Cols+j]<<' ';
134  }
135  ss<<data_[(Rows-1)*Cols+Cols-1]<<"],";
136  }
137  ss<<'[';
138  for(int j=0; j<Cols-1; ++j)
139  {
140  ss<<data_[(Rows-1)*Cols+j]<<' ';
141  }
142  ss<<data_[(Rows-1)*Cols+Cols-1]<<"]]";
143  return ss.str();
144  }
145 
146  detail::Row<Rows, Cols, Type> operator[](int row)
147  {
148  return detail::Row<Rows, Cols, Type>(this, row);
149  }
150 
151  detail::Row<Rows, Cols, Type> operator[](int row) const
152  {
153  // TODO got to fix this
154  return detail::Row<Rows, Cols, Type>((Matrix<Rows, Cols, Type>*)this, row);
155  }
156 
157  Matrix<Rows, Cols, Type>& operator=(const Matrix<Rows, Cols, Type> &other)
158  {
159  if(this!=&other)
160  {
161  data_=other.data_;
162  }
163  return *this;
164  }
165 
166  Matrix<Rows, Cols, Type>& operator+=(const Matrix<Rows, Cols, Type> &rhs)
167  {
168  std::vector<Type> out;
169  out.reserve(data_.size());
170  std::transform(data_.begin(), data_.end(), rhs.data_.begin(), std::back_inserter(out),
171  [] (Type a, Type b) {
172  return a+b;
173  });
174  data_=std::move(out);
175  return *this;
176  }
177 
178  Matrix<Rows, Cols, Type>& operator-=(const Matrix<Rows, Cols, Type> &rhs)
179  {
180  std::vector<Type> out;
181  out.reserve(data_.size());
182  std::transform(data_.begin(), data_.end(), rhs.begin(), std::back_inserter(out),
183  [] (Type a, Type b) {
184  return a-b;
185  });
186  data_=std::move(out);
187  return *this;
188  }
189 };
190 
191 template<int M, int N, class T>
192 Matrix<M, N, T> operator+(Matrix<M, N, T> lhs, const Matrix<M, N, T> &rhs)
193 {
194  lhs+=rhs;
195  return lhs;
196 }
197 
198 template<int M, int N, class T>
199 Matrix<M, N, T> operator-(Matrix<M, N, T> lhs, const Matrix<M, N, T> &rhs)
200 {
201  lhs-=rhs;
202  return lhs;
203 }
204 
205 template<int M, int N, class T>
206 Matrix<M, N, T> operator+(Matrix<M, N, T> lhs, const T &rhs)
207 {
208  for(auto &data : lhs)
209  {
210  data+=rhs;
211  }
212  return lhs;
213 }
214 
215 template<int M, int N, class T>
216 Matrix<M, N, T> operator+(const T &lhs, Matrix<M, N, T> rhs)
217 {
218  for(auto &data : rhs)
219  {
220  data+=lhs;
221  }
222  return rhs;
223 }
224 
225 template<int M, int N, class T>
226 Matrix<M, N, T> operator-(Matrix<M, N, T> lhs, const T &rhs)
227 {
228  for(auto &data : lhs)
229  {
230  data-=rhs;
231  }
232  return lhs;
233 }
234 
235 template<int M, int N, class T>
236 Matrix<M, N, T> operator-(const T &lhs, Matrix<M, N, T> rhs)
237 {
238  for(auto &data : rhs)
239  {
240  data=lhs-data;
241  }
242  return rhs;
243 }
244 
245 template<int M, int N, class T>
246 Matrix<M, N, T> operator*(Matrix<M, N, T> lhs, const T &rhs)
247 {
248  for(auto &data : lhs)
249  {
250  data*=rhs;
251  }
252  return lhs;
253 }
254 
255 template<int M, int N, class T>
256 Matrix<M, N, T> operator*(const T &lhs, Matrix<M, N, T> rhs)
257 {
258  for(auto &data : rhs)
259  {
260  data*=lhs;
261  }
262  return rhs;
263 }
264 
265 template<int M, int N, class T>
266 Matrix<M, N, T> operator/(Matrix<M, N, T> lhs, const T &rhs)
267 {
268  for(auto &data : lhs)
269  {
270  data/=rhs;
271  }
272  return lhs;
273 }
274 
275 template<int M, int N, class T>
276 bool operator==(const Matrix<M, N, T> &lhs, const Matrix<M, N, T> &rhs)
277 {
278  for(int i=0; i<M; ++i)
279  for(int j=0; j<N; ++j)
280  if(lhs[i][j]!=rhs[i][j])
281  return false;
282  return true;
283 }
284 
285 template<int M, int N, class T>
286 std::ostream& operator<<(std::ostream &os, const Matrix<M, N, T> &mat)
287 {
288  return os<<mat.toString();
289 }
290 
291 template<int Rows=2, class Type=double> class Vector : public Matrix<Rows, 1, Type>
292 {
293 public:
294  Vector<Rows, Type>() : Matrix<Rows, 1, Type>() {}
295  explicit Vector<Rows, Type>(const Matrix<Rows, 1, Type> &other) : Matrix<Rows, 1, Type>(other) {}
296 
297  Type& operator[](int col)
298  {
299  return this->data_[col];
300  }
301 
302  const Type& operator[](int col) const
303  {
304  return this->data_[col];
305  }
306 
307  virtual std::string toString() const
308  {
309  std::stringstream ss;
310  ss<<"[";
311  for(std::size_t i=0; i<this->data_.size()-1; ++i)
312  {
313  ss<<this->data_[i]<<" ";
314  }
315  ss<<this->data_[this->data_.size()-1]<<"]";
316  return ss.str();
317  }
318 };
319 
320 template<class Type=double> class Vector2 : public Vector<2, Type>
321 {
322 public:
323  Vector2<Type>() : Vector<2, Type>() {}
324 
325  Vector2<Type>(Type x, Type y)
326  {
327  this->data_[0]=x;
328  this->data_[1]=y;
329  }
330 
331  Vector2<Type>(const Matrix<2, 1, Type> &other) : Vector<2, Type>(other) {}
332 
333  Type& x()
334  {
335  return this->data_[0];
336  }
337 
338  const Type& x() const
339  {
340  return this->data_[0];
341  }
342 
343  Type& y()
344  {
345  return this->data_[1];
346  }
347 
348  const Type& y() const
349  {
350  return this->data_[1];
351  }
352 };
353 
354 typedef Vector2<double> Vector2d;
355 
356 namespace matrix
357 {
358 
359 template<int M, int N, class T> Matrix<N, M, T> transpose(const Matrix<M, N, T> &m)
360 {
361  Matrix<N, M, T> trans;
362  for(int i=0; i<M; ++i)
363  {
364  for(int j=0; j<N; ++j)
365  {
366  trans[j][i]=m[i][j];
367  }
368  }
369  return trans;
370 }
371 
372 template<int R, class T> T dot(const Matrix<R, 1, T> &m1, const Matrix<R, 1, T> &m2)
373 {
374  T sum=0;
375  for(int i=0; i<R; ++i)
376  {
377  sum += m1[i][0]*m2[i][0];
378  }
379  return sum;
380 }
381 
382 template<int M, int N, int P, int Q, class T>
383 Matrix<M, Q, T> multiply(const Matrix<M, N, T> &m1, const Matrix<P, Q, T> &m2)
384 {
385  if(N!=P)
386  {
387  throw std::runtime_error("Matrices don't have the right dimensions for multiplication");
388  }
389 
390  Matrix<M, Q, T> res;
391 
392  for(int i=0; i<M; ++i)
393  {
394  for(int j=0; j<Q; ++j)
395  {
396  res[i][j] = dot(transpose(m1.getRow(i)), m2.getCol(j));
397  }
398  }
399 
400  return res;
401 }
402 
403 } // matrix
404 
405 } // yage
406 
407 #endif
yage::Vector2
Definition: matrix.hpp:320
-
yage::detail::Row
Definition: matrix.hpp:39
-
yage::Vector
Definition: matrix.hpp:291
-
yage::Matrix
Definition: matrix.hpp:29
+Go to the documentation of this file.
1 /* ----------------------------------------------------------------------------
2  * matrix.hpp
3  *
4  * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
5  * See file LICENSE for more details
6  * ----------------------------------------------------------------------------
7  */
8 
22 #ifndef YAGE_MATH_MATRIX_HPP
23 #define YAGE_MATH_MATRIX_HPP
24 
25 #include <algorithm>
26 #include <exception>
27 #include <iostream>
28 #include <sstream>
29 #include <string>
30 #include <vector>
31 
32 namespace yage
33 {
34 
35 template<int Rows, int Cols, class Type> class Matrix;
36 
37 // includes implementation details that should not be accessible to the user
38 namespace detail
39 {
40 
41 // Row class
42 //
43 // Used to implement the double square bracket operator and be able
44 // to return the value by reference of the array.
45 template<int Rows, int Cols, class Type> class Row
46 {
47 private:
48  Matrix<Rows, Cols, Type> *parent_;
49  int index_;
50 
51 public:
52  Row<Rows, Cols, Type>(Matrix<Rows, Cols, Type> *parent, int index) :
53  parent_(parent), index_(index)
54  {}
55 
56  Type& operator[](int col)
57  {
58  // the index is the y-position of the element in the matrix
59  return parent_->data_[index_*Cols+col];
60  }
61 
62  const Type& operator[](int col) const
63  {
64  return parent_->data_[index_*Cols+col];
65  }
66 };
67 
68 } // detail
69 
70 // Matrix class
71 //
72 // Implements the base Matrix class that is inherited by other classes to make them more
73 // specific.
74 template<int Rows=4, int Cols=4, class Type=double> class Matrix
75 {
76  // friended with the row class so that it can access protected member data
77  friend class detail::Row<Rows, Cols, Type>;
78 protected:
79  std::vector<Type> data_;
80 
81 public:
82  Matrix<Rows, Cols, Type>() : data_(Rows*Cols) {}
83 
84  int rowSize() const
85  {
86  return Rows;
87  }
88 
89  int colSize() const
90  {
91  return Cols;
92  }
93 
94  // returns the row in a row matrix
95  Matrix<1, Cols, Type> getRow(int row) const
96  {
97  Matrix<1, Cols, Type> rowMatrix;
98  for(int i=0; i<Cols; ++i)
99  {
100  rowMatrix[0][i]=data_[row][i];
101  }
102  return rowMatrix;
103  }
104 
105  // returns the column in a column matrix
106  Matrix<Rows, 1, Type> getCol(int col) const
107  {
108  Matrix<Rows, 1, Type> colMatrix;
109  for(int i=0; i<Rows; ++i)
110  {
111  colMatrix[i][0]=data_[i][col];
112  }
113  return colMatrix;
114  }
115 
116  // iterator support for begin
117  typename std::vector<Type>::iterator begin()
118  {
119  return data_.begin();
120  }
121 
122  // iterator support for end
123  typename std::vector<Type>::iterator end()
124  {
125  return data_.end();
126  }
127 
128  // prints out the matrix, but can also be implemented by other classes to print data
129  // differently
130  virtual std::string toString() const
131  {
132  std::stringstream ss;
133  ss<<'[';
134  for(int i=0; i<Rows-1; ++i)
135  {
136  ss<<'[';
137  for(int j=0; j<Cols-1; ++j)
138  {
139  ss<<data_[i*Cols+j]<<' ';
140  }
141  ss<<data_[(Rows-1)*Cols+Cols-1]<<"],";
142  }
143  ss<<'[';
144  for(int j=0; j<Cols-1; ++j)
145  {
146  ss<<data_[(Rows-1)*Cols+j]<<' ';
147  }
148  ss<<data_[(Rows-1)*Cols+Cols-1]<<"]]";
149  return ss.str();
150  }
151 
152  detail::Row<Rows, Cols, Type> operator[](int row)
153  {
154  return detail::Row<Rows, Cols, Type>(this, row);
155  }
156 
157  detail::Row<Rows, Cols, Type> operator[](int row) const
158  {
159  // TODO got to fix this
160  return detail::Row<Rows, Cols, Type>((Matrix<Rows, Cols, Type>*)this, row);
161  }
162 
163  Matrix<Rows, Cols, Type>& operator=(const Matrix<Rows, Cols, Type> &other)
164  {
165  if(this!=&other)
166  {
167  data_=other.data_;
168  }
169  return *this;
170  }
171 
172  Matrix<Rows, Cols, Type>& operator+=(const Matrix<Rows, Cols, Type> &rhs)
173  {
174  std::vector<Type> out;
175  out.reserve(data_.size());
176  std::transform(data_.begin(), data_.end(), rhs.data_.begin(), std::back_inserter(out),
177  [] (Type a, Type b) {
178  return a+b;
179  });
180  data_=std::move(out);
181  return *this;
182  }
183 
184  Matrix<Rows, Cols, Type>& operator-=(const Matrix<Rows, Cols, Type> &rhs)
185  {
186  std::vector<Type> out;
187  out.reserve(data_.size());
188  std::transform(data_.begin(), data_.end(), rhs.begin(), std::back_inserter(out),
189  [] (Type a, Type b) {
190  return a-b;
191  });
192  data_=std::move(out);
193  return *this;
194  }
195 };
196 
197 template<int M, int N, class T>
198 Matrix<M, N, T> operator+(Matrix<M, N, T> lhs, const Matrix<M, N, T> &rhs)
199 {
200  lhs+=rhs;
201  return lhs;
202 }
203 
204 template<int M, int N, class T>
205 Matrix<M, N, T> operator-(Matrix<M, N, T> lhs, const Matrix<M, N, T> &rhs)
206 {
207  lhs-=rhs;
208  return lhs;
209 }
210 
211 template<int M, int N, class T>
212 Matrix<M, N, T> operator+(Matrix<M, N, T> lhs, const T &rhs)
213 {
214  for(auto &data : lhs)
215  {
216  data+=rhs;
217  }
218  return lhs;
219 }
220 
221 template<int M, int N, class T>
222 Matrix<M, N, T> operator+(const T &lhs, Matrix<M, N, T> rhs)
223 {
224  for(auto &data : rhs)
225  {
226  data+=lhs;
227  }
228  return rhs;
229 }
230 
231 template<int M, int N, class T>
232 Matrix<M, N, T> operator-(Matrix<M, N, T> lhs, const T &rhs)
233 {
234  for(auto &data : lhs)
235  {
236  data-=rhs;
237  }
238  return lhs;
239 }
240 
241 template<int M, int N, class T>
242 Matrix<M, N, T> operator-(const T &lhs, Matrix<M, N, T> rhs)
243 {
244  for(auto &data : rhs)
245  {
246  data=lhs-data;
247  }
248  return rhs;
249 }
250 
251 template<int M, int N, class T>
252 Matrix<M, N, T> operator*(Matrix<M, N, T> lhs, const T &rhs)
253 {
254  for(auto &data : lhs)
255  {
256  data*=rhs;
257  }
258  return lhs;
259 }
260 
261 template<int M, int N, class T>
262 Matrix<M, N, T> operator*(const T &lhs, Matrix<M, N, T> rhs)
263 {
264  for(auto &data : rhs)
265  {
266  data*=lhs;
267  }
268  return rhs;
269 }
270 
271 template<int M, int N, class T>
272 Matrix<M, N, T> operator/(Matrix<M, N, T> lhs, const T &rhs)
273 {
274  for(auto &data : lhs)
275  {
276  data/=rhs;
277  }
278  return lhs;
279 }
280 
281 template<int M, int N, class T>
282 bool operator==(const Matrix<M, N, T> &lhs, const Matrix<M, N, T> &rhs)
283 {
284  for(int i=0; i<M; ++i)
285  for(int j=0; j<N; ++j)
286  if(lhs[i][j]!=rhs[i][j])
287  return false;
288  return true;
289 }
290 
291 template<int M, int N, class T>
292 std::ostream& operator<<(std::ostream &os, const Matrix<M, N, T> &mat)
293 {
294  return os<<mat.toString();
295 }
296 
297 template<int Rows=2, class Type=double> class Vector : public Matrix<Rows, 1, Type>
298 {
299 public:
300  Vector<Rows, Type>() : Matrix<Rows, 1, Type>() {}
301  explicit Vector<Rows, Type>(const Matrix<Rows, 1, Type> &other) : Matrix<Rows, 1, Type>(other) {}
302 
303  Type& operator[](int col)
304  {
305  return this->data_[col];
306  }
307 
308  const Type& operator[](int col) const
309  {
310  return this->data_[col];
311  }
312 
313  virtual std::string toString() const
314  {
315  std::stringstream ss;
316  ss<<"[";
317  for(std::size_t i=0; i<this->data_.size()-1; ++i)
318  {
319  ss<<this->data_[i]<<" ";
320  }
321  ss<<this->data_[this->data_.size()-1]<<"]";
322  return ss.str();
323  }
324 };
325 
326 template<class Type=double> class Vector2 : public Vector<2, Type>
327 {
328 public:
329  Vector2<Type>() : Vector<2, Type>() {}
330 
331  Vector2<Type>(Type x, Type y)
332  {
333  this->data_[0]=x;
334  this->data_[1]=y;
335  }
336 
337  Vector2<Type>(const Matrix<2, 1, Type> &other) : Vector<2, Type>(other) {}
338 
339  Type& x()
340  {
341  return this->data_[0];
342  }
343 
344  const Type& x() const
345  {
346  return this->data_[0];
347  }
348 
349  Type& y()
350  {
351  return this->data_[1];
352  }
353 
354  const Type& y() const
355  {
356  return this->data_[1];
357  }
358 };
359 
360 typedef Vector2<double> Vector2d;
361 
362 namespace matrix
363 {
364 
365 template<int M, int N, class T> Matrix<N, M, T> transpose(const Matrix<M, N, T> &m)
366 {
367  Matrix<N, M, T> trans;
368  for(int i=0; i<M; ++i)
369  {
370  for(int j=0; j<N; ++j)
371  {
372  trans[j][i]=m[i][j];
373  }
374  }
375  return trans;
376 }
377 
378 template<int R, class T> T dot(const Matrix<R, 1, T> &m1, const Matrix<R, 1, T> &m2)
379 {
380  T sum=0;
381  for(int i=0; i<R; ++i)
382  {
383  sum += m1[i][0]*m2[i][0];
384  }
385  return sum;
386 }
387 
388 template<int M, int N, int P, int Q, class T>
389 Matrix<M, Q, T> multiply(const Matrix<M, N, T> &m1, const Matrix<P, Q, T> &m2)
390 {
391  if(N!=P)
392  {
393  throw std::runtime_error("Matrices don't have the right dimensions for multiplication");
394  }
395 
396  Matrix<M, Q, T> res;
397 
398  for(int i=0; i<M; ++i)
399  {
400  for(int j=0; j<Q; ++j)
401  {
402  res[i][j] = dot(transpose(m1.getRow(i)), m2.getCol(j));
403  }
404  }
405 
406  return res;
407 }
408 
409 } // matrix
410 
411 } // yage
412 
413 #endif
yage::Vector2
Definition: matrix.hpp:326
+
yage::detail::Row
Definition: matrix.hpp:45
+
yage::Vector
Definition: matrix.hpp:297
+
yage::Matrix
Definition: matrix.hpp:35
yage
Definition: camera2d.hpp:17
-- cgit