From 40acf9ddc8f700b45d05bb2098be23a93c3bfa6a Mon Sep 17 00:00:00 2001 From: cathook Date: Fri, 27 Jun 2014 18:24:38 +0800 Subject: fix dimension size error --- doc/html/Matrix_8h_source.html | 707 +++++++++++++++++++++-------------------- 1 file changed, 360 insertions(+), 347 deletions(-) (limited to 'doc/html/Matrix_8h_source.html') diff --git a/doc/html/Matrix_8h_source.html b/doc/html/Matrix_8h_source.html index 78bd53f..ab77c56 100644 --- a/doc/html/Matrix_8h_source.html +++ b/doc/html/Matrix_8h_source.html @@ -28,7 +28,7 @@ Logo
Templates -- Meow -  204.13.18 +  1.2.9
A C++ template contains kinds of interesting classes and functions
@@ -98,388 +98,401 @@ $(document).ready(function(){initNavTree('Matrix_8h_source.html','');});
43  size_t index(size_t r, size_t c) const {
44  return r * cols_ + c;
45  }
-
46  };
-
47 
-
48  Self<Myself> const self;
-
49 public:
-
56  Matrix(): self() { }
-
57 
-
65  Matrix(Matrix const& m): self(m.self, Self<Myself>::COPY_FROM) {
-
66  }
-
67 
-
77  Matrix(size_t r, size_t c, Entry const& e): self(Myself(r, c, e)) {
-
78  }
-
79 
-
81  ~Matrix() { }
-
82 
-
91  Matrix& copyFrom(Matrix const& m) {
-
92  self().copyFrom(m.self);
-
93  return *this;
-
94  }
-
95 
-
104  Matrix& referenceFrom(Matrix const& m) {
-
105  self().referenceFrom(m.self);
-
106  return *this;
-
107  }
-
108 
-
110  void reset(size_t r, size_t c, Entry const& e) {
-
111  self()->rows_ = r;
-
112  self()->cols_ = c;
-
113  self()->entries_.clear();
-
114  self()->entries_.resize(r * c, e);
-
115  }
-
116 
-
118  bool valid() const {
-
119  return (rows() > 0 && cols() > 0);
+
46 
+
47  void realSize() {
+
48  std::vector<Entry> tmp(entries_);
+
49  entries_.swap(tmp);
+
50  }
+
51  };
+
52 
+
53  Self<Myself> const self;
+
54 public:
+
61  Matrix(): self() { }
+
62 
+
70  Matrix(Matrix const& m): self(m.self, Self<Myself>::COPY_FROM) {
+
71  }
+
72 
+
82  Matrix(size_t r, size_t c, Entry const& e): self(Myself(r, c, e)) {
+
83  }
+
84 
+
86  ~Matrix() { }
+
87 
+
96  Matrix& copyFrom(Matrix const& m) {
+
97  self().copyFrom(m.self);
+
98  return *this;
+
99  }
+
100 
+
109  Matrix& referenceFrom(Matrix const& m) {
+
110  self().referenceFrom(m.self);
+
111  return *this;
+
112  }
+
113 
+
115  void reset(size_t r, size_t c, Entry const& e) {
+
116  self()->rows_ = r;
+
117  self()->cols_ = c;
+
118  self()->entries_.clear();
+
119  self()->entries_.resize(r * c, e);
120  }
121 
-
123  size_t rows() const {
-
124  return self->rows_;
+
123  bool valid() const {
+
124  return (rows() > 0 && cols() > 0);
125  }
126 
-
128  size_t cols() const {
-
129  return self->cols_;
+
128  size_t rows() const {
+
129  return self->rows_;
130  }
131 
-
133  size_t size() const {
-
134  return rows() * cols();
+
133  size_t cols() const {
+
134  return self->cols_;
135  }
136 
-
146  size_t rows(size_t r, Entry const& e) {
-
147  if (r != rows()) {
-
148  self()->entries_.resize(r * cols(), e);
-
149  self()->rows_ = r;
-
150  }
-
151  return rows();
-
152  }
-
153 
-
163  size_t cols(size_t c, Entry const& e) {
-
164  if (c != cols()) {
-
165  Self<Myself> const old(self, Self<Myself>::COPY_FROM);
-
166  self()->entries_.resize(rows() * c);
-
167  self()->cols_ = c;
-
168  for (size_t i = 0, I = rows(); i < I; i++) {
-
169  size_t j, J1 = std::min(old->cols_, cols()), J2 = cols();
-
170  for (j = 0; j < J1; j++)
-
171  self()->entries_[self->index(i, j)] = old->entries_[old->index(i, j)];
-
172  for (j = J1; j < J2; j++)
-
173  self()->entries_[self->index(i, j)] = e;
-
174  }
-
175  }
-
176  return cols();
-
177  }
-
178 
-
189  size_t size(size_t r, size_t c, Entry const& e) {
-
190  cols(c, e);
-
191  rows(r, e);
-
192  return rows() * cols();
-
193  }
-
194 
-
196  Entry entry(size_t r, size_t c) const {
-
197  return self->entries_[self->index(r, c)];
+
138  size_t size() const {
+
139  return rows() * cols();
+
140  }
+
141 
+
151  size_t rows(size_t r, Entry const& e) {
+
152  if (r != rows()) {
+
153  self()->entries_.resize(r * cols(), e);
+
154  self()->rows_ = r;
+
155  }
+
156  return rows();
+
157  }
+
158 
+
168  size_t cols(size_t c, Entry const& e) {
+
169  if (c != cols()) {
+
170  Self<Myself> const old(self, Self<Myself>::COPY_FROM);
+
171  self()->entries_.resize(rows() * c);
+
172  self()->cols_ = c;
+
173  for (size_t i = 0, I = rows(); i < I; i++) {
+
174  size_t j, J1 = std::min(old->cols_, cols()), J2 = cols();
+
175  for (j = 0; j < J1; j++)
+
176  self()->entries_[self->index(i, j)] = old->entries_[old->index(i, j)];
+
177  for (j = J1; j < J2; j++)
+
178  self()->entries_[self->index(i, j)] = e;
+
179  }
+
180  }
+
181  return cols();
+
182  }
+
183 
+
194  size_t size(size_t r, size_t c, Entry const& e) {
+
195  cols(c, e);
+
196  rows(r, e);
+
197  return rows() * cols();
198  }
199 
-
201  Entry entry(size_t r, size_t c, Entry const& e) {
-
202  self()->entries_[self->index(r, c)] = e;
-
203  return entry(r, c);
-
204  }
-
205 
-
207  EntryRef entryGet(size_t r, size_t c) {
-
208  return self()->entries_[self->index(r, c)];
-
209  }
-
210 
-
221  void entries(ssize_t rFirst, ssize_t rLast,
-
222  ssize_t cFirst, ssize_t cLast,
-
223  Entry const& e) {
-
224  for (ssize_t r = rFirst; r <= rLast; r++) {
-
225  for (ssize_t c = cFirst; c <=cFirst; c++) {
-
226  entry(r, c, e);
-
227  }
-
228  }
-
229  }
-
230 
-
242  Matrix subMatrix(size_t rFirst, size_t rLast,
-
243  size_t cFirst, size_t cLast) const {
-
244  if (rFirst > rLast || cFirst > cLast) return Matrix();
-
245  if (rFirst == 0 && cFirst == 0) {
-
246  Matrix ret(*this);
-
247  ret.size(rLast + 1, cLast + 1, Entry(0));
-
248  return ret;
-
249  }
-
250  Matrix ret(rLast - rFirst + 1, cLast - cFirst + 1, entry(rFirst, cFirst));
-
251  for (size_t r = rFirst; r <= rLast; r++)
-
252  for (size_t c = cFirst; c <= cLast; c++)
-
253  ret.entry(r - rFirst, c - cFirst, entry(r, c));
-
254  return ret;
-
255  }
-
256 
-
258  Matrix row(size_t r) const {
-
259  return subMatrix(r, r, 0, cols() - 1);
-
260  }
-
261 
-
263  Matrix col(size_t c) const {
-
264  return subMatrix(0, rows() - 1, c, c);
-
265  }
-
266 
-
268  Matrix positive() const {
-
269  return *this;
+
203  void clear() {
+
204  self()->rows_ = 0;
+
205  self()->cols_ = 0;
+
206  self()->entries_.clear();
+
207  self()->realSize();
+
208  }
+
209 
+
211  Entry entry(size_t r, size_t c) const {
+
212  return self->entries_[self->index(r, c)];
+
213  }
+
214 
+
216  Entry entry(size_t r, size_t c, Entry const& e) {
+
217  self()->entries_[self->index(r, c)] = e;
+
218  return entry(r, c);
+
219  }
+
220 
+
222  EntryRef entryGet(size_t r, size_t c) {
+
223  return self()->entries_[self->index(r, c)];
+
224  }
+
225 
+
236  void entries(ssize_t rFirst, ssize_t rLast,
+
237  ssize_t cFirst, ssize_t cLast,
+
238  Entry const& e) {
+
239  for (ssize_t r = rFirst; r <= rLast; r++) {
+
240  for (ssize_t c = cFirst; c <=cFirst; c++) {
+
241  entry(r, c, e);
+
242  }
+
243  }
+
244  }
+
245 
+
257  Matrix subMatrix(size_t rFirst, size_t rLast,
+
258  size_t cFirst, size_t cLast) const {
+
259  if (rFirst > rLast || cFirst > cLast) return Matrix();
+
260  if (rFirst == 0 && cFirst == 0) {
+
261  Matrix ret(*this);
+
262  ret.size(rLast + 1, cLast + 1, Entry(0));
+
263  return ret;
+
264  }
+
265  Matrix ret(rLast - rFirst + 1, cLast - cFirst + 1, entry(rFirst, cFirst));
+
266  for (size_t r = rFirst; r <= rLast; r++)
+
267  for (size_t c = cFirst; c <= cLast; c++)
+
268  ret.entry(r - rFirst, c - cFirst, entry(r, c));
+
269  return ret;
270  }
271 
-
273  Matrix negative() const {
-
274  Matrix ret(*this);
-
275  for (size_t r = 0, R = rows(); r < R; r++)
-
276  for (size_t c = 0, C = cols(); c < C; c++)
-
277  ret.entry(r, c, -ret.entry(r, c));
-
278  return ret;
-
279  }
-
280 
-
285  Matrix add(Matrix const& m) const {
-
286  if (rows() != m.rows() || cols() != m.cols()) return Matrix();
-
287  Matrix ret(*this);
-
288  for (size_t r = 0, R = rows(); r < R; r++)
-
289  for (size_t c = 0, C = cols(); c < C; c++)
-
290  ret.entry(r, c, ret.entry(r, c) + m.entry(r, c));
-
291  return ret;
-
292  }
-
293 
-
298  Matrix sub(Matrix const& m) const {
-
299  if (rows() != m.rows() || cols() != m.cols()) return Matrix();
-
300  Matrix ret(*this);
-
301  for (size_t r = 0, R = rows(); r < R; r++)
-
302  for (size_t c = 0, C = cols(); c < C; c++)
-
303  ret.entry(r, c, ret.entry(r, c) - m.entry(r, c));
-
304  return ret;
-
305  }
-
306 
-
311  Matrix mul(Matrix const& m) const {
-
312  if (cols() != m.rows()) return Matrix();
-
313  Matrix ret(rows(), m.cols(), Entry(0));
-
314  for (size_t r = 0, R = rows(); r < R; r++)
-
315  for (size_t c = 0, C = m.cols(); c < C; c++)
-
316  for (size_t k = 0, K = cols(); k < K; k++)
-
317  ret.entry(r, c, ret.entry(r, c) + entry(r, k) * m.entry(k, c));
-
318  return ret;
-
319  }
-
320 
-
322  Matrix mul(Entry const& s) const {
-
323  Matrix ret(*this);
-
324  for (size_t r = 0, R = rows(); r < R; r++)
-
325  for (size_t c = 0, C = cols(); c < C; c++)
-
326  ret.entry(r, c, ret.entry(r, c) * s);
-
327  return ret;
-
328  }
-
329 
-
331  Matrix div(Entry const& s) const {
-
332  Matrix ret(*this);
-
333  for (size_t r = 0, R = rows(); r < R; r++)
-
334  for (size_t c = 0, C = cols(); c < C; c++)
-
335  ret.entry(r, c, ret.entry(r, c) / s);
-
336  return ret;
-
337  }
-
338 
-
340  Matrix identity() const {
-
341  Matrix ret(*this);
-
342  ret.identitied();
-
343  return ret;
-
344  }
-
345 
-
351  Matrix& identitied() {
-
352  for (size_t r = 0, R = rows(); r < R; r++)
-
353  for (size_t c = 0, C = cols(); c < C; c++)
-
354  entry(r, c, (r == c ? Entry(1) : Entry(0)));
-
355  return *this;
-
356  }
-
357 
-
361  Matrix& diagonaled() {
-
362  triangulared();
-
363  for (size_t i = 0, I = rows(); i < I; ++i) {
-
364  for (size_t j = i + 1, J = cols(); j < J; ++j) {
-
365  entry(i, j, Entry(0));
-
366  }
-
367  }
-
368  return *this;
-
369  }
-
370 
-
374  Matrix diagonal() const {
-
375  Matrix ret(*this);
-
376  ret.diagonaled();
-
377  return ret;
-
378  }
-
379 
-
385  Matrix inverse() const {
-
386  if (rows() != cols() || rows() == 0) return Matrix<Entry>();
-
387  Matrix tmp(rows(), cols() * 2, Entry(0));
-
388  for (size_t r = 0, R = rows(); r < R; r++) {
-
389  for (size_t c = 0, C = cols(); c < C; c++) {
-
390  tmp.entry(r, c, entry(r, c));
-
391  tmp.entry(r, c + cols(), (r == c ? Entry(1) : Entry(0)));
-
392  }
-
393  }
-
394  tmp.triangulared();
-
395  for (ssize_t r = rows() - 1; r >= 0; r--) {
-
396  if (tmp(r, r) == Entry(0)) return Matrix<Entry>();
-
397  for (ssize_t r2 = r - 1; r2 >= 0; r2--) {
-
398  Entry rat(-tmp.entry(r2, r) / tmp.entry(r, r));
-
399  for (size_t c = r, C = tmp.cols(); c < C; c++) {
-
400  tmp.entry(r2, c, tmp.entry(r2, c) + rat * tmp(r, c));
-
401  }
-
402  }
-
403  Entry rat(tmp.entry(r, r));
-
404  for (size_t c = cols(), C = tmp.cols(); c < C; c++) {
-
405  tmp.entry(r, c - cols(), tmp.entry(r, c) / rat);
-
406  }
-
407  }
-
408  tmp.size(cols(), rows(), Entry(0));
-
409  return tmp;
-
410  }
-
411 
-
413  Matrix& inversed() {
-
414  copyFrom(inverse());
-
415  return *this;
-
416  }
-
417 
-
419  Matrix transpose() const {
-
420  Matrix ret(cols(), rows(), Entry(0));
-
421  for (size_t r = 0, R = cols(); r < R; r++)
-
422  for (size_t c = 0, C = rows(); c < C; c++)
-
423  ret.entry(r, c, entry(c, r));
-
424  return ret;
+
273  Matrix row(size_t r) const {
+
274  return subMatrix(r, r, 0, cols() - 1);
+
275  }
+
276 
+
278  Matrix col(size_t c) const {
+
279  return subMatrix(0, rows() - 1, c, c);
+
280  }
+
281 
+
283  Matrix positive() const {
+
284  return *this;
+
285  }
+
286 
+
288  Matrix negative() const {
+
289  Matrix ret(*this);
+
290  for (size_t r = 0, R = rows(); r < R; r++)
+
291  for (size_t c = 0, C = cols(); c < C; c++)
+
292  ret.entry(r, c, -ret.entry(r, c));
+
293  return ret;
+
294  }
+
295 
+
300  Matrix add(Matrix const& m) const {
+
301  if (rows() != m.rows() || cols() != m.cols()) return Matrix();
+
302  Matrix ret(*this);
+
303  for (size_t r = 0, R = rows(); r < R; r++)
+
304  for (size_t c = 0, C = cols(); c < C; c++)
+
305  ret.entry(r, c, ret.entry(r, c) + m.entry(r, c));
+
306  return ret;
+
307  }
+
308 
+
313  Matrix sub(Matrix const& m) const {
+
314  if (rows() != m.rows() || cols() != m.cols()) return Matrix();
+
315  Matrix ret(*this);
+
316  for (size_t r = 0, R = rows(); r < R; r++)
+
317  for (size_t c = 0, C = cols(); c < C; c++)
+
318  ret.entry(r, c, ret.entry(r, c) - m.entry(r, c));
+
319  return ret;
+
320  }
+
321 
+
326  Matrix mul(Matrix const& m) const {
+
327  if (cols() != m.rows()) return Matrix();
+
328  Matrix ret(rows(), m.cols(), Entry(0));
+
329  for (size_t r = 0, R = rows(); r < R; r++)
+
330  for (size_t c = 0, C = m.cols(); c < C; c++)
+
331  for (size_t k = 0, K = cols(); k < K; k++)
+
332  ret.entry(r, c, ret.entry(r, c) + entry(r, k) * m.entry(k, c));
+
333  return ret;
+
334  }
+
335 
+
337  Matrix mul(Entry const& s) const {
+
338  Matrix ret(*this);
+
339  for (size_t r = 0, R = rows(); r < R; r++)
+
340  for (size_t c = 0, C = cols(); c < C; c++)
+
341  ret.entry(r, c, ret.entry(r, c) * s);
+
342  return ret;
+
343  }
+
344 
+
346  Matrix div(Entry const& s) const {
+
347  Matrix ret(*this);
+
348  for (size_t r = 0, R = rows(); r < R; r++)
+
349  for (size_t c = 0, C = cols(); c < C; c++)
+
350  ret.entry(r, c, ret.entry(r, c) / s);
+
351  return ret;
+
352  }
+
353 
+
355  Matrix identity() const {
+
356  Matrix ret(*this);
+
357  ret.identitied();
+
358  return ret;
+
359  }
+
360 
+
366  Matrix& identitied() {
+
367  for (size_t r = 0, R = rows(); r < R; r++)
+
368  for (size_t c = 0, C = cols(); c < C; c++)
+
369  entry(r, c, (r == c ? Entry(1) : Entry(0)));
+
370  return *this;
+
371  }
+
372 
+
376  Matrix& diagonaled() {
+
377  triangulared();
+
378  for (size_t i = 0, I = rows(); i < I; ++i) {
+
379  for (size_t j = i + 1, J = cols(); j < J; ++j) {
+
380  entry(i, j, Entry(0));
+
381  }
+
382  }
+
383  return *this;
+
384  }
+
385 
+
389  Matrix diagonal() const {
+
390  Matrix ret(*this);
+
391  ret.diagonaled();
+
392  return ret;
+
393  }
+
394 
+
400  Matrix inverse() const {
+
401  if (rows() != cols() || rows() == 0) return Matrix<Entry>();
+
402  Matrix tmp(rows(), cols() * 2, Entry(0));
+
403  for (size_t r = 0, R = rows(); r < R; r++) {
+
404  for (size_t c = 0, C = cols(); c < C; c++) {
+
405  tmp.entry(r, c, entry(r, c));
+
406  tmp.entry(r, c + cols(), (r == c ? Entry(1) : Entry(0)));
+
407  }
+
408  }
+
409  tmp.triangulared();
+
410  for (ssize_t r = rows() - 1; r >= 0; r--) {
+
411  if (tmp(r, r) == Entry(0)) return Matrix<Entry>();
+
412  for (ssize_t r2 = r - 1; r2 >= 0; r2--) {
+
413  Entry rat(-tmp.entry(r2, r) / tmp.entry(r, r));
+
414  for (size_t c = r, C = tmp.cols(); c < C; c++) {
+
415  tmp.entry(r2, c, tmp.entry(r2, c) + rat * tmp(r, c));
+
416  }
+
417  }
+
418  Entry rat(tmp.entry(r, r));
+
419  for (size_t c = cols(), C = tmp.cols(); c < C; c++) {
+
420  tmp.entry(r, c - cols(), tmp.entry(r, c) / rat);
+
421  }
+
422  }
+
423  tmp.size(cols(), rows(), Entry(0));
+
424  return tmp;
425  }
426 
-
428  Matrix& transposed() {
-
429  copyFrom(transpose());
+
428  Matrix& inversed() {
+
429  copyFrom(inverse());
430  return *this;
431  }
432 
-
434  Matrix triangular() const {
-
435  Matrix<Entry> ret(*this);
-
436  ret.triangulared();
-
437  return ret;
-
438  }
-
439 
-
441  Matrix& triangulared() {
-
442  for (size_t r = 0, c = 0, R = rows(), C = cols(); r < R && c < C; r++) {
-
443  ssize_t maxR;
-
444  for ( ; c < C; c++) {
-
445  maxR = -1;
-
446  for (size_t r2 = r; r2 < R; r2++)
-
447  if (maxR == -1 || tAbs(entry(r2, c)) > tAbs(entry(maxR, c)))
-
448  maxR = r2;
-
449  if (entry(maxR, c) != Entry(0)) break;
-
450  }
-
451  if (c >= C) break;
-
452  if (maxR != (ssize_t)r) {
-
453  for (size_t c2 = c; c2 < C; c2++)
-
454  std::swap(self()->entries_[self->index( r, c2)],
-
455  self()->entries_[self->index(maxR, c2)]);
-
456  }
-
457  for (size_t r2 = r + 1; r2 < R; r2++) {
-
458  Entry rati = -entry(r2, c) / entry(r, c);
-
459  entry(r2, c, Entry(0));
-
460  for (size_t c2 = c + 1; c2 < C; c2++)
-
461  entry(r2, c2, entry(r2, c2) + entry(r, c2) * rati);
-
462  }
-
463  }
-
464  return *this;
-
465  }
-
466 
-
468  Matrix& operator=(Matrix const& m) {
-
469  return copyFrom(m);
-
470  }
-
471 
-
473  Entry operator()(size_t r, size_t c) const {
-
474  return entry(r, c);
-
475  }
-
476 
-
478  Entry operator()(size_t r, size_t c, Entry const& e) {
-
479  return entry(r, c, e);
+
434  Matrix transpose() const {
+
435  Matrix ret(cols(), rows(), Entry(0));
+
436  for (size_t r = 0, R = cols(); r < R; r++)
+
437  for (size_t c = 0, C = rows(); c < C; c++)
+
438  ret.entry(r, c, entry(c, r));
+
439  return ret;
+
440  }
+
441 
+
443  Matrix& transposed() {
+
444  copyFrom(transpose());
+
445  return *this;
+
446  }
+
447 
+
449  Matrix triangular() const {
+
450  Matrix<Entry> ret(*this);
+
451  ret.triangulared();
+
452  return ret;
+
453  }
+
454 
+
456  Matrix& triangulared() {
+
457  for (size_t r = 0, c = 0, R = rows(), C = cols(); r < R && c < C; r++) {
+
458  ssize_t maxR;
+
459  for ( ; c < C; c++) {
+
460  maxR = -1;
+
461  for (size_t r2 = r; r2 < R; r2++)
+
462  if (maxR == -1 || tAbs(entry(r2, c)) > tAbs(entry(maxR, c)))
+
463  maxR = r2;
+
464  if (entry(maxR, c) != Entry(0)) break;
+
465  }
+
466  if (c >= C) break;
+
467  if (maxR != (ssize_t)r) {
+
468  for (size_t c2 = c; c2 < C; c2++)
+
469  std::swap(self()->entries_[self->index( r, c2)],
+
470  self()->entries_[self->index(maxR, c2)]);
+
471  }
+
472  for (size_t r2 = r + 1; r2 < R; r2++) {
+
473  Entry rati = -entry(r2, c) / entry(r, c);
+
474  entry(r2, c, Entry(0));
+
475  for (size_t c2 = c + 1; c2 < C; c2++)
+
476  entry(r2, c2, entry(r2, c2) + entry(r, c2) * rati);
+
477  }
+
478  }
+
479  return *this;
480  }
481 
-
483  Matrix operator+() const {
-
484  return positive();
+
483  Matrix& operator=(Matrix const& m) {
+
484  return copyFrom(m);
485  }
486 
-
488  Matrix operator-() const {
-
489  return negative();
+
488  Entry operator()(size_t r, size_t c) const {
+
489  return entry(r, c);
490  }
491 
-
493  Matrix operator+(Matrix const& m) const {
-
494  return add(m);
+
493  Entry operator()(size_t r, size_t c, Entry const& e) {
+
494  return entry(r, c, e);
495  }
496 
-
498  Matrix operator-(Matrix const& m) const {
-
499  return sub(m);
+
498  Matrix operator+() const {
+
499  return positive();
500  }
501 
-
503  Matrix operator*(Matrix const& m) const {
-
504  return mul(m);
+
503  Matrix operator-() const {
+
504  return negative();
505  }
506 
-
508  Matrix operator*(Entry const& s) const {
-
509  return mul(s);
+
508  Matrix operator+(Matrix const& m) const {
+
509  return add(m);
510  }
511 
-
513  Matrix operator/(Entry const& s) const {
-
514  return div(s);
+
513  Matrix operator-(Matrix const& m) const {
+
514  return sub(m);
515  }
-
516 };
-
517 
-
518 } // meow
-
519 
-
520 #endif // math_Matrix_H__
-
meow::Matrix::col
Matrix col(size_t c) const
Return the c -th column.
Definition: Matrix.h:263
-
meow::Matrix::triangulared
Matrix & triangulared()
triangluar itself
Definition: Matrix.h:441
+
516 
+
518  Matrix operator*(Matrix const& m) const {
+
519  return mul(m);
+
520  }
+
521 
+
523  Matrix operator*(Entry const& s) const {
+
524  return mul(s);
+
525  }
+
526 
+
528  Matrix operator/(Entry const& s) const {
+
529  return div(s);
+
530  }
+
531 };
+
532 
+
533 } // meow
+
534 
+
535 #endif // math_Matrix_H__
+
meow::Matrix::col
Matrix col(size_t c) const
Return the c -th column.
Definition: Matrix.h:278
+
meow::Matrix::triangulared
Matrix & triangulared()
triangluar itself
Definition: Matrix.h:456
meow::Matrix::EntryRefK
std::vector< Entry >::const_reference EntryRefK
Definition: Matrix.h:21
-
meow::Matrix::referenceFrom
Matrix & referenceFrom(Matrix const &m)
reference
Definition: Matrix.h:104
-
meow::Matrix::rows
size_t rows() const
Return number of rows.
Definition: Matrix.h:123
-
meow::Matrix::operator*
Matrix operator*(Entry const &s) const
same as mul(m)
Definition: Matrix.h:508
-
meow::Matrix::div
Matrix div(Entry const &s) const
return (*this) / s. s is a scalar
Definition: Matrix.h:331
-
meow::Matrix::operator+
Matrix operator+() const
same as positive()
Definition: Matrix.h:483
+
meow::Matrix::referenceFrom
Matrix & referenceFrom(Matrix const &m)
reference
Definition: Matrix.h:109
+
meow::Matrix::rows
size_t rows() const
Return number of rows.
Definition: Matrix.h:128
+
meow::Matrix::operator*
Matrix operator*(Entry const &s) const
same as mul(m)
Definition: Matrix.h:523
+
meow::Matrix::div
Matrix div(Entry const &s) const
return (*this) / s. s is a scalar
Definition: Matrix.h:346
+
meow::Matrix::operator+
Matrix operator+() const
same as positive()
Definition: Matrix.h:498
meow::Matrix::EntryRef
std::vector< Entry >::reference EntryRef
Definition: Matrix.h:20
-
meow::Matrix::rows
size_t rows(size_t r, Entry const &e)
resize the matrix such that number of rows become r.
Definition: Matrix.h:146
-
meow::Matrix::transposed
Matrix & transposed()
Let itself become itself's transpose matrix.
Definition: Matrix.h:428
-
meow::Matrix::cols
size_t cols() const
Return number of cols.
Definition: Matrix.h:128
-
meow::Matrix::operator()
Entry operator()(size_t r, size_t c, Entry const &e)
same as entry(r,c,e)
Definition: Matrix.h:478
-
meow::Matrix::inverse
Matrix inverse() const
Return a matrix which is an inverse matrix of (*this)
Definition: Matrix.h:385
-
meow::Matrix::subMatrix
Matrix subMatrix(size_t rFirst, size_t rLast, size_t cFirst, size_t cLast) const
Return a rLast-rFirst+1 x cLast-cFirst+1 matrix.
Definition: Matrix.h:242
-
meow::Matrix::valid
bool valid() const
Return whether it is a valid matrix.
Definition: Matrix.h:118
-
meow::Matrix::operator*
Matrix operator*(Matrix const &m) const
same as mul(m)
Definition: Matrix.h:503
-
meow::Matrix::row
Matrix row(size_t r) const
Return the r -th row.
Definition: Matrix.h:258
-
meow::Matrix::operator=
Matrix & operator=(Matrix const &m)
same as copyFrom
Definition: Matrix.h:468
-
meow::Matrix::Matrix
Matrix()
constructor
Definition: Matrix.h:56
-
meow::Matrix::diagonal
Matrix diagonal() const
Return a matrix which is a diangonal form of me.
Definition: Matrix.h:374
-
meow::Matrix::Matrix
Matrix(Matrix const &m)
constructor
Definition: Matrix.h:65
-
meow::Matrix::copyFrom
Matrix & copyFrom(Matrix const &m)
copy
Definition: Matrix.h:91
+
meow::Matrix::rows
size_t rows(size_t r, Entry const &e)
resize the matrix such that number of rows become r.
Definition: Matrix.h:151
+
meow::Matrix::transposed
Matrix & transposed()
Let itself become itself's transpose matrix.
Definition: Matrix.h:443
+
meow::Matrix::cols
size_t cols() const
Return number of cols.
Definition: Matrix.h:133
+
meow::Matrix::operator()
Entry operator()(size_t r, size_t c, Entry const &e)
same as entry(r,c,e)
Definition: Matrix.h:493
+
meow::Matrix::inverse
Matrix inverse() const
Return a matrix which is an inverse matrix of (*this)
Definition: Matrix.h:400
+
meow::Matrix::subMatrix
Matrix subMatrix(size_t rFirst, size_t rLast, size_t cFirst, size_t cLast) const
Return a rLast-rFirst+1 x cLast-cFirst+1 matrix.
Definition: Matrix.h:257
+
meow::Matrix::valid
bool valid() const
Return whether it is a valid matrix.
Definition: Matrix.h:123
+
meow::Matrix::operator*
Matrix operator*(Matrix const &m) const
same as mul(m)
Definition: Matrix.h:518
+
meow::Matrix::row
Matrix row(size_t r) const
Return the r -th row.
Definition: Matrix.h:273
+
meow::Matrix::operator=
Matrix & operator=(Matrix const &m)
same as copyFrom
Definition: Matrix.h:483
+
meow::Matrix::Matrix
Matrix()
constructor
Definition: Matrix.h:61
+
meow::Matrix::diagonal
Matrix diagonal() const
Return a matrix which is a diangonal form of me.
Definition: Matrix.h:389
+
meow::Matrix::Matrix
Matrix(Matrix const &m)
constructor
Definition: Matrix.h:70
+
meow::Matrix::copyFrom
Matrix & copyFrom(Matrix const &m)
copy
Definition: Matrix.h:96
meow::tAbs
T tAbs(T const &t)
就只是個取絕對值
Definition: utility.h:141
-
meow::Matrix::Matrix
Matrix(size_t r, size_t c, Entry const &e)
constructor
Definition: Matrix.h:77
-
meow::Matrix::entries
void entries(ssize_t rFirst, ssize_t rLast, ssize_t cFirst, ssize_t cLast, Entry const &e)
Change the entries from rFirst x cFirst to rLast x cLast.
Definition: Matrix.h:221
-
meow::Matrix::size
size_t size() const
Return number of rows times number of cols.
Definition: Matrix.h:133
-
meow::Matrix::size
size_t size(size_t r, size_t c, Entry const &e)
resize
Definition: Matrix.h:189
-
meow::Matrix::identity
Matrix identity() const
Return a identity matrix with size equal to itself.
Definition: Matrix.h:340
-
meow::Matrix::diagonaled
Matrix & diagonaled()
Let itself be an diagonal form of original itself.
Definition: Matrix.h:361
-
meow::Matrix::transpose
Matrix transpose() const
return itself's transpose matrix
Definition: Matrix.h:419
-
meow::Matrix::~Matrix
~Matrix()
destructor
Definition: Matrix.h:81
-
meow::Matrix::mul
Matrix mul(Matrix const &m) const
return (*this) times m.
Definition: Matrix.h:311
-
meow::Matrix::mul
Matrix mul(Entry const &s) const
return (*this) times s. s is a scalar
Definition: Matrix.h:322
-
meow::Matrix::entryGet
EntryRef entryGet(size_t r, size_t c)
Get the entry at r x c.
Definition: Matrix.h:207
-
meow::Matrix::inversed
Matrix & inversed()
let itself become itself's inverse matrix
Definition: Matrix.h:413
-
meow::Matrix::sub
Matrix sub(Matrix const &m) const
return (*this) - m.
Definition: Matrix.h:298
-
meow::Matrix::operator+
Matrix operator+(Matrix const &m) const
same as add(m)
Definition: Matrix.h:493
-
meow::Matrix::operator()
Entry operator()(size_t r, size_t c) const
same as entry(r,c)
Definition: Matrix.h:473
+
meow::Matrix::Matrix
Matrix(size_t r, size_t c, Entry const &e)
constructor
Definition: Matrix.h:82
+
meow::Matrix::entries
void entries(ssize_t rFirst, ssize_t rLast, ssize_t cFirst, ssize_t cLast, Entry const &e)
Change the entries from rFirst x cFirst to rLast x cLast.
Definition: Matrix.h:236
+
meow::Matrix::size
size_t size() const
Return number of rows times number of cols.
Definition: Matrix.h:138
+
meow::Matrix::size
size_t size(size_t r, size_t c, Entry const &e)
resize
Definition: Matrix.h:194
+
meow::Matrix::clear
void clear()
free the memory
Definition: Matrix.h:203
+
meow::Matrix::identity
Matrix identity() const
Return a identity matrix with size equal to itself.
Definition: Matrix.h:355
+
meow::Matrix::diagonaled
Matrix & diagonaled()
Let itself be an diagonal form of original itself.
Definition: Matrix.h:376
+
meow::Matrix::transpose
Matrix transpose() const
return itself's transpose matrix
Definition: Matrix.h:434
+
meow::Matrix::~Matrix
~Matrix()
destructor
Definition: Matrix.h:86
+
meow::Matrix::mul
Matrix mul(Matrix const &m) const
return (*this) times m.
Definition: Matrix.h:326
+
meow::Matrix::mul
Matrix mul(Entry const &s) const
return (*this) times s. s is a scalar
Definition: Matrix.h:337
+
meow::Matrix::entryGet
EntryRef entryGet(size_t r, size_t c)
Get the entry at r x c.
Definition: Matrix.h:222
+
meow::Matrix::inversed
Matrix & inversed()
let itself become itself's inverse matrix
Definition: Matrix.h:428
+
meow::Matrix::sub
Matrix sub(Matrix const &m) const
return (*this) - m.
Definition: Matrix.h:313
+
meow::Matrix::operator+
Matrix operator+(Matrix const &m) const
same as add(m)
Definition: Matrix.h:508
+
meow::Matrix::operator()
Entry operator()(size_t r, size_t c) const
same as entry(r,c)
Definition: Matrix.h:488
meow::Matrix
matrix
Definition: Matrix.h:18
-
meow::Matrix::operator-
Matrix operator-() const
same as negative()
Definition: Matrix.h:488
-
meow::Matrix::entry
Entry entry(size_t r, size_t c, Entry const &e)
Change the entry at r x c.
Definition: Matrix.h:201
-
meow::Matrix::identitied
Matrix & identitied()
Let itself be an identity matrix.
Definition: Matrix.h:351
-
meow::Matrix::entry
Entry entry(size_t r, size_t c) const
Access the entry at r x c.
Definition: Matrix.h:196
-
meow::Matrix::negative
Matrix negative() const
return -(*this)
Definition: Matrix.h:273
+
meow::Matrix::operator-
Matrix operator-() const
same as negative()
Definition: Matrix.h:503
+
meow::Matrix::entry
Entry entry(size_t r, size_t c, Entry const &e)
Change the entry at r x c.
Definition: Matrix.h:216
+
meow::Matrix::identitied
Matrix & identitied()
Let itself be an identity matrix.
Definition: Matrix.h:366
+
meow::Matrix::entry
Entry entry(size_t r, size_t c) const
Access the entry at r x c.
Definition: Matrix.h:211
+
meow::Matrix::negative
Matrix negative() const
return -(*this)
Definition: Matrix.h:288
meow::Self< Myself >
-
meow::Matrix::cols
size_t cols(size_t c, Entry const &e)
resize the matrix such that number of cols become c
Definition: Matrix.h:163
-
meow::Matrix::operator/
Matrix operator/(Entry const &s) const
same as div(s)
Definition: Matrix.h:513
-
meow::Matrix::positive
Matrix positive() const
return +(*this)
Definition: Matrix.h:268
-
meow::Matrix::reset
void reset(size_t r, size_t c, Entry const &e)
reset the size of the matrix to r x c with entry all be e
Definition: Matrix.h:110
-
meow::Matrix::operator-
Matrix operator-(Matrix const &m) const
same as sub(m)
Definition: Matrix.h:498
-
meow::Matrix::triangular
Matrix triangular() const
return a matrix which is the triangular form of (*this)
Definition: Matrix.h:434
-
meow::Matrix::add
Matrix add(Matrix const &m) const
return (*this) + m.
Definition: Matrix.h:285
+
meow::Matrix::cols
size_t cols(size_t c, Entry const &e)
resize the matrix such that number of cols become c
Definition: Matrix.h:168
+
meow::Matrix::operator/
Matrix operator/(Entry const &s) const
same as div(s)
Definition: Matrix.h:528
+
meow::Matrix::positive
Matrix positive() const
return +(*this)
Definition: Matrix.h:283
+
meow::Matrix::reset
void reset(size_t r, size_t c, Entry const &e)
reset the size of the matrix to r x c with entry all be e
Definition: Matrix.h:115
+
meow::Matrix::operator-
Matrix operator-(Matrix const &m) const
same as sub(m)
Definition: Matrix.h:513
+
meow::Matrix::triangular
Matrix triangular() const
return a matrix which is the triangular form of (*this)
Definition: Matrix.h:449
+
meow::Matrix::add
Matrix add(Matrix const &m) const
return (*this) + m.
Definition: Matrix.h:300
@@ -487,7 +500,7 @@ $(document).ready(function(){initNavTree('Matrix_8h_source.html','');});