SHARE
TWEET

Untitled

a guest Feb 23rd, 2019 83 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <iostream>
  2. #include <string>
  3. #include <vector>
  4. #include <utility>
  5. #include <algorithm>
  6. #include <cassert>
  7.  
  8. using namespace std;
  9.  
  10. template<typename T>
  11. class Matrix;
  12.  
  13. template<typename T>
  14. class MatrixIterator {
  15. private:
  16.     const Matrix<T>& matrix;
  17.     size_t row;
  18.     size_t column;
  19.  
  20. public:
  21.     MatrixIterator(const Matrix<T>& m, size_t i, size_t j) : matrix(m), row(i), column(j) {
  22.     }
  23.  
  24.     bool operator == (MatrixIterator other) const {
  25.         return row == other.row && column == other.column;
  26.     }
  27.  
  28.     bool operator != (MatrixIterator other) const {
  29.         return !(*this == other);
  30.     }
  31.  
  32.     const T& operator * () const {
  33.         return matrix[row][column];
  34.     }
  35.  
  36.     MatrixIterator& operator++ () {
  37.         ++column;
  38.         if (column == matrix[0].size()) {
  39.             ++row;
  40.             column = 0;
  41.         }
  42.         return *this;
  43.     }
  44.  
  45.     MatrixIterator operator++ (int) {
  46.         auto tmp = *this;
  47.         ++*this;
  48.         return tmp;
  49.     }
  50. };
  51.  
  52. template<typename T>
  53. class NoMatrixIterator {
  54. private:
  55.     Matrix<T>& matrix;
  56.     size_t row;
  57.     size_t column;
  58.  
  59. public:
  60.     NoMatrixIterator(Matrix<T>& m, size_t i, size_t j) : matrix(m), row(i), column(j) {
  61.     }
  62.  
  63.     bool operator == (NoMatrixIterator other) const {
  64.         return row == other.row && column == other.column;
  65.     }
  66.  
  67.     bool operator != (NoMatrixIterator other) const {
  68.         return !(*this == other);
  69.     }
  70.  
  71.     T& operator * () const {
  72.         return matrix[row][column];
  73.     }
  74.  
  75.     NoMatrixIterator& operator++ () {
  76.         ++column;
  77.         if (column == matrix[0].size()) {
  78.             ++row;
  79.             column = 0;
  80.         }
  81.         return *this;
  82.     }
  83.  
  84.     NoMatrixIterator operator++ (int) {
  85.         auto tmp = *this;
  86.         ++*this;
  87.         return tmp;
  88.     }
  89. };
  90.  
  91. template<typename T>
  92. class Matrix {
  93. private:
  94.     size_t N;
  95.     size_t M;
  96.     vector<vector<T> > data;
  97.  
  98. public:
  99.     Matrix(const vector<vector<T> >& a) {
  100.         data = a;
  101.         N = a.size();
  102.         M = a[0].size();
  103.     }
  104.  
  105.     NoMatrixIterator<T> begin() {
  106.         return{ *this, 0, 0 };
  107.     }
  108.  
  109.     const MatrixIterator<T> begin() const {
  110.         return{ *this, 0, 0 };
  111.     }
  112.  
  113.     NoMatrixIterator<T> end() {
  114.         return{ *this, data.size(), 0 };
  115.     }
  116.  
  117.     const MatrixIterator<T> end() const {
  118.         return{ *this, data.size(), 0 };
  119.     }
  120.  
  121.     const vector<T>& operator[] (size_t i) const {
  122.         return data[i];
  123.     }
  124.  
  125.     vector<T>& operator[] (size_t i) {
  126.         return data[i];
  127.     }
  128.  
  129.     pair<size_t, size_t> size() const {
  130.         return make_pair(N, M);
  131.     }
  132.  
  133.     Matrix<T>& operator += (const Matrix<T>& a) {
  134.         for (size_t i = 0; i < N; ++i) {
  135.             for (size_t j = 0; j < M; ++j) {
  136.                 data[i][j] += a[i][j];
  137.             }
  138.         }
  139.         return *this;
  140.     }
  141.  
  142.     Matrix<T> operator + (const Matrix<T>& a) const {
  143.         Matrix<T> ans(data);
  144.         ans += a;
  145.         return ans;
  146.     }
  147.  
  148.     template<typename B>
  149.     Matrix<T>& operator *= (const B& a) {
  150.         for (size_t i = 0; i < N; ++i) {
  151.             for (size_t j = 0; j < M; ++j) {
  152.                 data[i][j] *= a;
  153.             }
  154.         }
  155.         return *this;
  156.     }
  157.  
  158.     template<typename B>
  159.     Matrix<T> operator * (const B& a) const {
  160.         Matrix<T> ans(data);
  161.         ans *= a;
  162.         return ans;
  163.     }
  164.  
  165.     Matrix<T>& transpose() {
  166.         vector<vector<T> > a;
  167.         a.resize(M);
  168.         for (size_t i = 0; i < M; ++i) {
  169.             a[i].resize(N);
  170.         }
  171.         for (size_t i = 0; i < M; ++i) {
  172.             for (size_t j = 0; j < N; ++j) {
  173.                 a[i][j] = data[j][i];
  174.             }
  175.         }
  176.         Matrix<T> ans(a);
  177.         data = ans.data;
  178.         M = ans.M;
  179.         N = ans.N;
  180.         return *this;
  181.     }
  182.  
  183.     Matrix<T> transposed() const {
  184.         vector<vector<T> > a;
  185.         a.resize(M);
  186.         for (size_t i = 0; i < M; ++i) {
  187.             a[i].resize(N);
  188.         }
  189.         for (size_t i = 0; i < M; ++i) {
  190.             for (size_t j = 0; j < N; ++j) {
  191.                 a[i][j] = data[j][i];
  192.             }
  193.         }
  194.         Matrix<T> ans(a);
  195.         return a;
  196.     }
  197.  
  198.     Matrix<T>& operator *= (const Matrix<T> a) {
  199.         assert(M == a.N);
  200.         vector<vector<T> > q;
  201.         q.resize(N);
  202.         for (size_t i = 0; i < N; ++i) {
  203.             q[i].resize(a.M);
  204.         }
  205.         for (size_t i = 0; i < N; ++i) {
  206.             for (size_t j = 0; j < a.M; ++j) {
  207.                 for (size_t k = 0; k < M; ++k) {
  208.                     q[i][j] += data[i][k] * a.data[k][j];
  209.                 }
  210.             }
  211.         }
  212.         data = q;
  213.         M = a.M;
  214.         return *this;
  215.     }
  216.  
  217.     Matrix<T> operator * (const Matrix<T>& a) const {
  218.         assert(M == a.N);
  219.         vector<vector<T> > q;
  220.         q.resize(N);
  221.         for (size_t i = 0; i < N; ++i) {
  222.             q[i].resize(a.M);
  223.         }
  224.         for (size_t i = 0; i < N; ++i) {
  225.             for (size_t j = 0; j < a.M; ++j) {
  226.                 for (size_t k = 0; k < M; ++k) {
  227.                     q[i][j] += data[i][k] * a.data[k][j];
  228.                 }
  229.             }
  230.         }
  231.         Matrix<T> ans(q);
  232.         return ans;
  233.     }
  234. };
  235.  
  236. template<typename T>
  237. ostream& operator<<(ostream& out, const Matrix<T>& m) {
  238.     for (size_t i = 0; i < m.size().first; ++i) {
  239.         for (size_t j = 0; j < m.size().second; ++j) {
  240.             if (j == m.size().second - 1) {
  241.                 out << m[i][j];
  242.             } else {
  243.                 out << m[i][j] << "\t";
  244.             }
  245.         }
  246.         if (i == m.size().first - 1) {
  247.             continue;
  248.         }
  249.         out << "\n";
  250.     }
  251.     return out;
  252. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top