From d65c91fee87f7ddf0abb1d9102b1f3ee42fe267e Mon Sep 17 00:00:00 2001 From: csyer <2960069894@qq.com> Date: Thu, 22 Feb 2024 19:53:46 +0800 Subject: [PATCH] add vector --- README.md | 6 +- vector/README.md | 19 + vector/data/class-bint.hpp | 516 +++++++++++++ vector/data/class-integer.hpp | 11 + vector/data/class-matrix.hpp | 266 +++++++ vector/data/four.memcheck/answer.txt | 22 + vector/data/four.memcheck/code.cpp | 32 + vector/data/four/answer.txt | 22 + vector/data/four/code.cpp | 32 + vector/data/one.memcheck/answer.txt | 69 ++ vector/data/one.memcheck/code.cpp | 132 ++++ vector/data/one/answer.txt | 69 ++ vector/data/one/code.cpp | 132 ++++ vector/data/three.memcheck/answer.txt | 80 ++ vector/data/three.memcheck/code.cpp | 51 ++ vector/data/three/answer.txt | 80 ++ vector/data/three/code.cpp | 51 ++ vector/data/two.memcheck/answer.txt | 1025 +++++++++++++++++++++++++ vector/data/two.memcheck/code.cpp | 22 + vector/data/two/answer.txt | 1025 +++++++++++++++++++++++++ vector/data/two/code.cpp | 22 + vector/src/exceptions.hpp | 39 + vector/src/utility.hpp | 27 + vector/src/vector.hpp | 226 ++++++ 24 files changed, 3974 insertions(+), 2 deletions(-) create mode 100644 vector/README.md create mode 100644 vector/data/class-bint.hpp create mode 100644 vector/data/class-integer.hpp create mode 100644 vector/data/class-matrix.hpp create mode 100644 vector/data/four.memcheck/answer.txt create mode 100644 vector/data/four.memcheck/code.cpp create mode 100644 vector/data/four/answer.txt create mode 100644 vector/data/four/code.cpp create mode 100644 vector/data/one.memcheck/answer.txt create mode 100644 vector/data/one.memcheck/code.cpp create mode 100644 vector/data/one/answer.txt create mode 100644 vector/data/one/code.cpp create mode 100644 vector/data/three.memcheck/answer.txt create mode 100644 vector/data/three.memcheck/code.cpp create mode 100644 vector/data/three/answer.txt create mode 100644 vector/data/three/code.cpp create mode 100644 vector/data/two.memcheck/answer.txt create mode 100644 vector/data/two.memcheck/code.cpp create mode 100644 vector/data/two/answer.txt create mode 100644 vector/data/two/code.cpp create mode 100644 vector/src/exceptions.hpp create mode 100644 vector/src/utility.hpp create mode 100644 vector/src/vector.hpp diff --git a/README.md b/README.md index 05aa1ae..d2a06c8 100644 --- a/README.md +++ b/README.md @@ -15,7 +15,7 @@ ## 评测方法 -测试数据将全部下发（见本仓库），供调试使用。最终测试将会在OJ上进行，并进行code review。 +测试数据将全部下发（见本仓库），供调试使用。最终测试将会在 OJ 上进行，并进行 code review。 ## 分数构成 @@ -23,7 +23,9 @@ ## 截止日期 -待定 +`vector`：3 月 3 日（第二周周日）18:30 前 + +未完待续 ## 迟交惩罚 diff --git a/vector/README.md b/vector/README.md new file mode 100644 index 0000000..d1f09fc --- /dev/null +++ b/vector/README.md @@ -0,0 +1,19 @@ +# STLite-Vector + +## 实现细节 + +Vector 的基本实现要求在总项目文档和`vector.hpp`中已经给出，最终提交仅需要提交`vector.hpp`的内容。 + +可能需要注意的细节： + +- 在测试点中，有一些类并不具有默认构造函数，所以直接使用`T* p=new T[...];`可能会出现问题。 +- 你的程序将会受到一定程度的鲁棒性检测 + +## 分数构成 + +OJ 测试部分占比：80%，code review 部分占比：20% + +## 截止日期 + +3 月 3 日（第二周周日）18:30 前 + diff --git a/vector/data/class-bint.hpp b/vector/data/class-bint.hpp new file mode 100644 index 0000000..0b2ad9c --- /dev/null +++ b/vector/data/class-bint.hpp @@ -0,0 +1,516 @@ +#include +#include +#include +#include +#include +#include + +namespace Util { + +const size_t MIN_CAPACITY = 2048; + +class Bint { + class NewSpaceFailed : public std::runtime_error { + public: + NewSpaceFailed(); + }; + class BadCast : public std::invalid_argument { + public: + BadCast(); + }; + bool isMinus = false; + size_t length; + int *data = nullptr; + size_t capacity = MIN_CAPACITY; + void _DoubleSpace(); + void _SafeNewSpace(int *&p, const size_t &len); + explicit Bint(const size_t &capa); +public: + Bint(); + Bint(int x); + Bint(long long x); + Bint(std::string x); + Bint(const Bint &b); + Bint(Bint &&b) noexcept; + + Bint &operator=(int rhs); + Bint &operator=(long long rhs); + Bint &operator=(const Bint &rhs); + Bint &operator=(Bint &&rhs) noexcept; + + friend Bint abs(const Bint &x); + friend Bint abs(Bint &&x); + + friend bool operator==(const Bint &lhs, const Bint &rhs); + friend bool operator!=(const Bint &lhs, const Bint &rhs); + friend bool operator<(const Bint &lhs, const Bint &rhs); + friend bool operator>(const Bint &lhs, const Bint &rhs); + friend bool operator<=(const Bint &lhs, const Bint &rhs); + friend bool operator>=(const Bint &lhs, const Bint &rhs); + + friend Bint operator+(const Bint &lhs, const Bint &rhs); + friend Bint operator-(const Bint &b); + friend Bint operator-(Bint &&b); + friend Bint operator-(const Bint &lhs, const Bint &rhs); + friend Bint operator*(const Bint &lhs, const Bint &rhs); + + friend std::istream &operator>>(std::istream &is, Bint &b); + friend std::ostream &operator<<(std::ostream &os, const Bint &b); + + ~Bint(); +}; +} + +#include +#include + +namespace Util { + +Bint::NewSpaceFailed::NewSpaceFailed() : std::runtime_error("No Enough Memory Space.") {} +Bint::BadCast::BadCast() : std::invalid_argument("Cannot convert to a Bint object") {} + +void Bint::_SafeNewSpace(int *&p, const size_t &len) +{ + if (p != nullptr) { + delete[] p; + p = nullptr; + } + p = new int[len]; + if (p == nullptr) { + throw NewSpaceFailed(); + } + memset(p, 0, len * sizeof(unsigned int)); +} + +void Bint::_DoubleSpace() +{ + int *newMem = nullptr; + _SafeNewSpace(newMem, capacity << 1); + memcpy(newMem, data, capacity * sizeof(int)); + delete[] data; + data = newMem; + capacity <<= 1; +} + +Bint::Bint() + : length(1) +{ + _SafeNewSpace(data, capacity); +} + +Bint::Bint(int x) + : length(0) +{ + _SafeNewSpace(data, capacity); + if (x < 0) { + isMinus = true; + x = -x; + } + while (x) { + data[length++] = x % 10000; + x /= 10000; + } + if (!length) { + length = 1; + } +} + +Bint::Bint(long long x) + : length(0) +{ + _SafeNewSpace(data, capacity); + if (x < 0) { + isMinus = true; + x = -x; + } + while (x) { + data[length++] = static_cast(x % 10000); + x /= 10000; + } + if (!length) { + length = 1; + } +} + +Bint::Bint(const size_t &capa) + : length(1) +{ + while (capacity < capa) { + capacity <<= 1; + } + _SafeNewSpace(data, capacity); +} + +Bint::Bint(std::string x) +{ + while (x[0] == '-') { + isMinus = !isMinus; + x.erase(0, 1); + } + while ((capacity << 2) <= x.length()) { + capacity <<= 1; + } + + _SafeNewSpace(data, capacity); + + size_t mid = x.length() >> 1; + for (size_t i = 0; i < mid; ++i) { + std::swap(x[i], x[x.length() - 1 - i]); + } + + const static unsigned int pow10[4] = {1, 10, 100, 1000}; + for (size_t i = 0; i < capacity; ++i) { + if ((i << 2) >= x.length()) { + length = i; + break; + } + for (size_t j = 0; j < 4; ++j) { + if ((i << 2) + j >= x.length()) { + break; + } + if (x[(i << 2) + j] > '9' || x[(i << 2) + j] < '0') { + throw BadCast(); + } + data[i] = data[i] + (x[(i << 2) + j] - '0') * pow10[j]; + } + } +} + +Bint::Bint(const Bint &b) + : isMinus(b.isMinus), length(b.length), capacity(b.capacity) +{ + _SafeNewSpace(data, capacity); + memcpy(data, b.data, sizeof(unsigned int) * capacity); +} + +Bint::Bint(Bint &&b) noexcept + : isMinus(b.isMinus), length(b.length), capacity(b.capacity) +{ + data = b.data; + b.data = nullptr; +} + +Bint &Bint::operator=(int x) +{ + memset(data, 0, sizeof(unsigned int) * capacity); + length = 0; + if (x < 0) { + isMinus = true; + x = -x; + } + while (x) { + data[length++] = x % 10000; + x /= 10000; + } + if (!length) { + length = 1; + } + return *this; +} + +Bint &Bint::operator=(long long x) +{ + memset(data, 0, sizeof(unsigned int) * capacity); + length = 0; + if (x < 0) { + isMinus = true; + x = -x; + } + while (x) { + data[length++] = static_cast(x % 10000); + x /= 10000; + } + if (!length) { + length = 1; + } + return *this; +} + +Bint &Bint::operator=(const Bint &rhs) +{ + if (this == &rhs) { + return *this; + } + if (rhs.capacity > capacity) { + capacity = rhs.capacity; + _SafeNewSpace(data, capacity); + } + memcpy(data, rhs.data, sizeof(unsigned int) * rhs.capacity); + length = rhs.length; + isMinus = rhs.isMinus; + return *this; +} + +Bint &Bint::operator=(Bint &&rhs) noexcept +{ + if (this == &rhs) { + return *this; + } + capacity = rhs.capacity; + length = rhs.length; + isMinus = rhs.isMinus; + data = rhs.data; + rhs.data = nullptr; + return *this; +} + +std::istream &operator>>(std::istream &is, Bint &b) +{ + std::string s; + is >> s; + b = Bint(s); + return is; +} + +std::ostream &operator<<(std::ostream &os, const Bint &b) +{ + if (b.data == nullptr) { + return os; + } + if (b.isMinus && (b.length > 1 || b.data[0] != 0)) { + os << "-"; + } + os << b.data[b.length - 1]; + for (long long i = b.length - 2LL; i >= 0; --i) { + os << std::setw(4) << std::setfill('0') << b.data[i]; + } + return os; +} + +Bint abs(const Bint &b) +{ + Bint result(b); + result.isMinus = false; + return result; +} + +Bint abs(Bint &&b) +{ + b.isMinus = false; + return b; +} + +bool operator==(const Bint &lhs, const Bint &rhs) +{ + if (lhs.isMinus != rhs.isMinus) { + return false; + } + if (lhs.length != rhs.length) { + return false; + } + for (size_t i = 0; i < lhs.length; ++i) { + if (lhs.data[i] != rhs.data[i]) { + return false; + } + } + return true; +} + +bool operator!=(const Bint &lhs, const Bint &rhs) +{ + if (lhs.isMinus != rhs.isMinus) { + return true; + } + if (lhs.length != rhs.length) { + return true; + } + for (size_t i = 0; i < lhs.length; ++i) { + if (lhs.data[i] != rhs.data[i]) { + return true; + } + } + return false; +} + +bool operator<(const Bint &lhs, const Bint &rhs) +{ + if (lhs.isMinus != rhs.isMinus) { + return !lhs.isMinus; + } + if (lhs.isMinus) { + if (lhs.length != rhs.length) { + return lhs.length > rhs.length; + } + for (long long i = lhs.length - 1; i >= 0; --i) { + if (lhs.data[i] != rhs.data[i]) { + return lhs.data[i] > rhs.data[i]; + } + } + return false; + } else { + if (lhs.length != rhs.length) { + return lhs.length < rhs.length; + } + for (long long i = lhs.length - 1; i >= 0; --i) { + if (lhs.data[i] != rhs.data[i]) { + return lhs.data[i] < rhs.data[i]; + } + } + return false; + } +} + +bool operator>(const Bint &lhs, const Bint &rhs) +{ + return rhs < lhs; +} + +bool operator<=(const Bint &lhs, const Bint &rhs) +{ + if (lhs.isMinus != rhs.isMinus) { + return !lhs.isMinus; + } + if (lhs.isMinus) { + if (lhs.length != rhs.length) { + return lhs.length > rhs.length; + } + for (long long i = lhs.length - 1; i >= 0; --i) { + if (lhs.data[i] != rhs.data[i]) { + return lhs.data[i] > rhs.data[i]; + } + } + return true; + } else { + if (lhs.length != rhs.length) { + return lhs.length < rhs.length; + } + for (long long i = lhs.length - 1; i >= 0; --i) { + if (lhs.data[i] != rhs.data[i]) { + return lhs.data[i] < rhs.data[i]; + } + } + return true; + } +} + +bool operator>=(const Bint &lhs, const Bint &rhs) +{ + if (lhs.isMinus != rhs.isMinus) { + return lhs.isMinus; + } + if (lhs.isMinus) { + if (lhs.length != rhs.length) { + return lhs.length < rhs.length; + } + for (long long i = lhs.length - 1; i >= 0; --i) { + if (lhs.data[i] != rhs.data[i]) { + return lhs.data[i] < rhs.data[i]; + } + } + return true; + } else { + if (lhs.length != rhs.length) { + return lhs.length > rhs.length; + } + for (long long i = lhs.length - 1; i >= 0; --i) { + if (lhs.data[i] != rhs.data[i]) { + return lhs.data[i] > rhs.data[i]; + } + } + return true; + } +} + + +Bint operator+(const Bint &lhs, const Bint &rhs) +{ + if (lhs.isMinus == rhs.isMinus) { + size_t maxLen = std::max(lhs.length, rhs.length); + size_t expectLen = maxLen + 1; + Bint result(expectLen); // special constructor + for (size_t i = 0; i < maxLen; ++i) { + result.data[i] = lhs.data[i] + rhs.data[i]; + } + for (size_t i = 0; i < maxLen; ++i) { + if (result.data[i] > 10000) { + result.data[i] -= 10000; + ++result.data[i + 1]; + } + } + result.length = result.data[maxLen] > 0 ? maxLen + 1 : maxLen; + result.isMinus = lhs.isMinus; + return result; + } else { + if (lhs.isMinus) { + return rhs - abs(lhs); + } else { + return lhs - abs(rhs); + } + } +} + +Bint operator-(const Bint &b) +{ + Bint result(b); + result.isMinus = !result.isMinus; + return result; +} + +Bint operator-(Bint &&b) +{ + b.isMinus = !b.isMinus; + return b; +} + +Bint operator-(const Bint &lhs, const Bint &rhs) +{ + if (lhs.isMinus == rhs.isMinus) { + if (lhs.isMinus) { + return -(abs(lhs) - abs(rhs)); + } else { + if (lhs < rhs) { + return -(rhs - lhs); + } + Bint result(std::max(lhs.length, rhs.length)); + for (size_t i = 0; i < lhs.length; ++i) { + result.data[i] = lhs.data[i] - rhs.data[i]; + } + for (size_t i = 0; i < lhs.length; ++i) { + if (result.data[i] < 0) { + result.data[i] += 10000; + ++result.data[i + 1]; + } + } + while (result.length > 1 && result.data[result.length - 1] == 0) { + --result.length; + } + return result; + } + } else { + return lhs + (-rhs); + } +} + +Bint operator*(const Bint &lhs, const Bint &rhs) +{ + size_t expectLen = lhs.length + rhs.length + 2; + Bint result(expectLen); + for (size_t i = 0; i < lhs.length; ++i) { + for (size_t j = 0; j < rhs.length; ++j) { + long long tmp = result.data[i + j] + static_cast(lhs.data[i]) * rhs.data[j]; + if (tmp >= 10000) { + result.data[i + j] = tmp % 10000; + result.data[i + j + 1] += static_cast(tmp / 10000); + } else { + result.data[i + j] = tmp; + } + } + } + result.length = lhs.length + rhs.length -1; + while (result.data[result.length] > 0) { + ++result.length; + } + while (result.length > 1 && result.data[result.length - 1] == 0) { + --result.length; + } + return result; +} + +Bint::~Bint() +{ + if (data != nullptr) { + delete[] data; + data = nullptr; + } +} +} diff --git a/vector/data/class-integer.hpp b/vector/data/class-integer.hpp new file mode 100644 index 0000000..92942f7 --- /dev/null +++ b/vector/data/class-integer.hpp @@ -0,0 +1,11 @@ +class Integer { +private: + int data; +public: + Integer(const int &value) : data(value) {} + Integer(const Integer &other) : data(other.data) {} + bool operator==(const Integer &t) + { + return data == t.data; + } +}; diff --git a/vector/data/class-matrix.hpp b/vector/data/class-matrix.hpp new file mode 100644 index 0000000..ba57f72 --- /dev/null +++ b/vector/data/class-matrix.hpp @@ -0,0 +1,266 @@ +#ifndef DIAMOND_MATRIX_HPP +#define DIAMOND_MATRIX_HPP + +#include +#include +#include +#include + +namespace Diamond { + +template +class Matrix { +protected: + size_t n_rows = 0; + size_t n_cols = 0; + std::vector> data; + class RowProxy { + std::vector<_Td> &row; + public: + RowProxy(std::vector<_Td> & _row) : row(_row) {} + _Td & operator[](const size_t &pos) + { + return row[pos]; + } + }; + class ConstRowProxy { + const std::vector<_Td> &row; + public: + ConstRowProxy(const std::vector<_Td> &_row) : row(_row) {} + const _Td & operator[](const size_t &pos) const + { + return row[pos]; + } + }; +public: + Matrix() {}; + Matrix(const size_t &_n_rows, const size_t &_n_cols) + : n_rows(_n_rows), n_cols(_n_cols), data(std::vector>(n_rows, std::vector<_Td>(n_cols))) {} + Matrix(const size_t &_n_rows, const size_t &_n_cols, const _Td &fillValue) + : n_rows(_n_rows), n_cols(_n_cols), data(std::vector>(n_rows, std::vector<_Td>(n_cols, fillValue))) {} + Matrix(const Matrix<_Td> &mat) + : n_rows(mat.n_rows), n_cols(mat.n_cols), data(mat.data) {} + Matrix(Matrix<_Td> &&mat) noexcept + : n_rows(mat.n_rows), n_cols(mat.n_cols), data(mat.data) {} + Matrix<_Td> & operator=(const Matrix<_Td> &rhs) + { + this->n_rows = rhs.n_rows; + this->n_cols = rhs.n_cols; + this->data = rhs.data; + return *this; + } + Matrix<_Td> & operator=(Matrix<_Td> &&rhs) + { + this->n_rows = rhs.n_rows; + this->n_cols = rhs.n_cols; + this->data = rhs.data; + return *this; + } + inline const size_t & RowSize() const + { + return n_rows; + } + inline const size_t & ColSize() const + { + return n_cols; + } + RowProxy operator[](const size_t &Kth) + { + return RowProxy(this->data[Kth]); + } + const ConstRowProxy operator[](const size_t &Kth) const + { + return ConstRowProxy(this->data[Kth]); + } + ~Matrix() = default; +}; + +/** + * Sum of two matrics. + */ +template +Matrix<_Td> operator+(const Matrix<_Td> &a, const Matrix<_Td> &b) +{ + if (a.RowSize() != b.RowSize() || a.ColSize() != b.ColSize()) { + throw std::invalid_argument("different matrics\'s sizes"); + } + Matrix<_Td> c(a.RowSize(), a.ColSize()); + for (size_t i = 0; i < a.RowSize(); ++i) { + for (size_t j = 0; j < a.ColSize(); ++j) { + c[i][j] = a[i][j] + b[i][j]; + } + } + return c; +} + +template +Matrix<_Td> operator-(const Matrix<_Td> &a, const Matrix<_Td> &b) +{ + if (a.RowSize() != b.RowSize() || a.ColSize() != b.ColSize()) { + throw std::invalid_argument("different matrics\'s sizes"); + } + Matrix<_Td> c(a.RowSize(), a.ColSize()); + for (size_t i = 0; i < a.RowSize(); ++i) { + for (size_t j = 0; j < a.ColSize(); ++j) { + c[i][j] = a[i][j] - b[i][j]; + } + } + return c; +} +template +bool operator==(const Matrix<_Td> &a, const Matrix<_Td> &b) +{ + if (a.RowSize() != b.RowSize() || a.ColSize() != b.ColSize()) { + return false; + } + for (size_t i = 0; i < a.RowSize(); ++i) { + for (size_t j = 0; j < a.ColSize(); ++j) { + if (a[i][j] != b[i][j]) + return false; + } + } + return true; +} + +template +Matrix<_Td> operator-(const Matrix<_Td> &mat) +{ + Matrix<_Td> result(mat.RowSize(), mat.ColSize()); + for (size_t i = 0; i < mat.RowSize(); ++i) { + for (size_t j = 0; j < mat.ColSize(); ++j) { + result[i][j] = -mat[i][j]; + } + } + return result; +} + +template +Matrix<_Td> operator-(Matrix<_Td> &&mat) +{ + for (size_t i = 0; i < mat.RowSize(); ++i) { + for (size_t j = 0; j < mat.ColSize(); ++j) { + mat[i][j] = -mat[i][j]; + } + } + return mat; +} + +/** + * Multiplication of two matrics. + */ +template +Matrix<_Td> operator*(const Matrix<_Td> &a, const Matrix<_Td> &b) +{ + if (a.ColSize() != b.RowSize()) { + throw std::invalid_argument("different matrics\'s sizes"); + } + Matrix<_Td> c(a.RowSize(), b.ColSize(), 0); + for (size_t i = 0; i < a.RowSize(); ++i) { + for (size_t j = 0; j < b.ColSize(); ++j) { + for (size_t k = 0; k < a.ColSize(); ++k) { + c[i][j] += a[i][k] * b[k][j]; + } + } + } + return c; +} + +/** + * Operations between a number and a matrix; + */ +template +Matrix<_Td> operator*(const Matrix<_Td> &a, const _Td &b) +{ + Matrix<_Td> c(a.RowSize(), a.ColSize()); + for (size_t i = 0; i < a.RowSize(); ++i) { + for (size_t j = 0; j < a.ColSize(); ++j) { + c[i][j] = a[i][j] * b; + } + } + return c; +} + +template +Matrix<_Td> operator*(const _Td &b, const Matrix<_Td> &a) +{ + Matrix<_Td> c(a.RowSize(), a.ColSize()); + for (size_t i = 0; i < a.RowSize(); ++i) { + for (size_t j = 0; j < a.ColSize(); ++j) { + c[i][j] = a[i][j] * b; + } + } + return c; +} + +template +Matrix<_Td> operator/(const Matrix<_Td> &a, const double &b) +{ + Matrix<_Td> c(a.RowSize(), a.ColSize()); + for (size_t i = 0; i < a.RowSize(); ++i) { + for (size_t j = 0; j < a.ColSize(); ++j) { + c[i][j] = a[i][j] / b; + } + } + return c; +} + +template +Matrix<_Td> Transpose(const Matrix<_Td> &a) +{ + Matrix<_Td> res(a.ColSize(), a.RowSize()); + for (size_t i = 0; i < a.ColSize(); ++i) { + for (size_t j = 0; j < a.RowSize(); ++j) { + res[i][j] = a[j][i]; + } + } + return res; +} + +template +std::ostream & operator<<(std::ostream &stream, const Matrix<_Td> &mat) +{ + std::ostream::fmtflags oldFlags = stream.flags(); + stream.precision(8); + stream.setf(std::ios::fixed | std::ios::right); + + stream << '\n'; + for (size_t i = 0; i < mat.RowSize(); ++i) { + for (size_t j = 0; j < mat.ColSize(); ++j) { + stream << std::setw(15) << mat[i][j]; + } + stream << '\n'; + } + + stream.flags(oldFlags); + return stream; +} + +template +Matrix<_Td> I(const size_t &n) +{ + Matrix<_Td> res(n, n, 0); + for (size_t i = 0; i < n; ++i) { + res[i][i] = static_cast<_Td>(1); + } + return res; +} + +template +Matrix<_Td> Pow(Matrix<_Td> A, size_t &b) +{ + if (A.RowSize() != A.ColSize()) { + throw std::invalid_argument("The row size and column size are different."); + } + Matrix<_Td> result = I<_Td>(A.ColSize()); + while (b > 0) { + if (b & static_cast(1)) { + result = result * A; + } + A = A * A; + b = b >> static_cast(1); + } + return result; +} + +} +#endif diff --git a/vector/data/four.memcheck/answer.txt b/vector/data/four.memcheck/answer.txt new file mode 100644 index 0000000..729f6c6 --- /dev/null +++ b/vector/data/four.memcheck/answer.txt @@ -0,0 +1,22 @@ +Supplementary test for large amounts of data ... +550658 +15523 +552292 +13889 +553926 +12255 +555560 +10621 +557194 +8987 +558828 +7353 +560462 +5719 +562096 +4085 +563730 +2451 +565364 +817 +Finished! diff --git a/vector/data/four.memcheck/code.cpp b/vector/data/four.memcheck/code.cpp new file mode 100644 index 0000000..ff1d8bc --- /dev/null +++ b/vector/data/four.memcheck/code.cpp @@ -0,0 +1,32 @@ +//provided by ivy + +#include "vector.hpp" +#include "class-matrix.hpp" +#include "class-bint.hpp" +#include + +void complex_test() +{ + std::cout << "Supplementary test for large amounts of data ..." << std::endl; + sjtu::vector> myVec; + for (int i = 1; i <= 1926; ++i) + myVec.push_back(Diamond::Matrix(i % 8 + 1, i % 17 + 1, Util::Bint(i * 817))); + int o = 1234; + while (o--) + myVec.pop_back(); + myVec = myVec; + int _ = 20, __ = myVec.size(); + while (_--) + { + if (_ % 2 == 0) + std::cout << myVec[_][0][0] << std::endl; + else + std::cout << myVec[__ - _][0][0] << std::endl; + } + std::cout << "Finished!" << std::endl; +} + +int main() +{ + complex_test(); +} \ No newline at end of file diff --git a/vector/data/four/answer.txt b/vector/data/four/answer.txt new file mode 100644 index 0000000..729f6c6 --- /dev/null +++ b/vector/data/four/answer.txt @@ -0,0 +1,22 @@ +Supplementary test for large amounts of data ... +550658 +15523 +552292 +13889 +553926 +12255 +555560 +10621 +557194 +8987 +558828 +7353 +560462 +5719 +562096 +4085 +563730 +2451 +565364 +817 +Finished! diff --git a/vector/data/four/code.cpp b/vector/data/four/code.cpp new file mode 100644 index 0000000..ff1d8bc --- /dev/null +++ b/vector/data/four/code.cpp @@ -0,0 +1,32 @@ +//provided by ivy + +#include "vector.hpp" +#include "class-matrix.hpp" +#include "class-bint.hpp" +#include + +void complex_test() +{ + std::cout << "Supplementary test for large amounts of data ..." << std::endl; + sjtu::vector> myVec; + for (int i = 1; i <= 1926; ++i) + myVec.push_back(Diamond::Matrix(i % 8 + 1, i % 17 + 1, Util::Bint(i * 817))); + int o = 1234; + while (o--) + myVec.pop_back(); + myVec = myVec; + int _ = 20, __ = myVec.size(); + while (_--) + { + if (_ % 2 == 0) + std::cout << myVec[_][0][0] << std::endl; + else + std::cout << myVec[__ - _][0][0] << std::endl; + } + std::cout << "Finished!" << std::endl; +} + +int main() +{ + complex_test(); +} \ No newline at end of file diff --git a/vector/data/one.memcheck/answer.txt b/vector/data/one.memcheck/answer.txt new file mode 100644 index 0000000..f400511 --- /dev/null +++ b/vector/data/one.memcheck/answer.txt @@ -0,0 +1,69 @@ +Testing constructors and assignment operator... +1 2 3 4 5 6 7 8 9 10 +0 1 2 3 4 5 6 7 8 9 +1 2 3 4 5 6 7 8 9 10 +Testing iterators... +1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 +1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 +Testing accessing methods... +1 +2 +4 +8 +16 +32 +64 +128 +256 +512 +1024 +2048 +4096 +8192 +16384 +32768 +65536 +131072 +262144 +524288 +1048576 +2097152 +4194304 +8388608 +16777216 +33554432 +67108864 +134217728 +268435456 +536870912 +1073741824 +2147483648 +4294967296 +8589934592 +17179869184 +34359738368 +68719476736 +137438953472 +274877906944 +549755813888 +1099511627776 +2199023255552 +4398046511104 +8796093022208 +17592186044416 +35184372088832 +70368744177664 +140737488355328 +281474976710656 +562949953421312 +exceptions thrown correctly. +Testing push_back and pop_back... +9 +22 +21 +20 +5 +Testing insert functions +0 1 2 100 3 200 4 5 6 7 8 9 +Testing erase functions +0 1 2 3 4 5 6 7 8 9 diff --git a/vector/data/one.memcheck/code.cpp b/vector/data/one.memcheck/code.cpp new file mode 100644 index 0000000..4360888 --- /dev/null +++ b/vector/data/one.memcheck/code.cpp @@ -0,0 +1,132 @@ +#include "vector.hpp" + +#include +#include +#include + +void TestConstructor() +{ + std::cout << "Testing constructors and assignment operator..." << std::endl; + sjtu::vector v; + for (int i = 1; i <= 10; ++i) { + v.push_back(i); + } + const sjtu::vector vc(v); + for (size_t i = 0; i < vc.size(); ++i) { + std::cout << vc[i] << " "; + } + std::cout << std::endl; + sjtu::vector vv; + for (int i = 0; i < 10; ++i) { + vv.push_back(i); + } + for (size_t i = 0; i < vv.size(); ++i) { + std::cout << vv[i] << " "; + } + std::cout << std::endl; + vv = v; + for (size_t i = 0; i < vv.size(); ++i) { + std::cout << vv[i] << " "; + } + std::cout << std::endl; +} + +void TestIterators() +{ + std::cout << "Testing iterators..." << std::endl; + sjtu::vector v; + for (int i = 1; i <= 20; ++i) { + v.push_back(i); + } + for (sjtu::vector::iterator it = v.begin(); it != v.end(); ++it) { + std::cout << *it << " "; + } + std::cout << std::endl; + const sjtu::vector vc(v); + for (sjtu::vector::const_iterator it = vc.cbegin(); it != vc.cend(); ++it) { + std::cout << *it << " "; + } + std::cout << std::endl; +} + +void TestAccessingMethod() +{ + std::cout << "Testing accessing methods..." << std::endl; + sjtu::vector vd; + for (long long i = 0; i < 50; ++i) { + vd.push_back(1LL << i); + } + for (size_t i = 0; i < vd.size(); ++i) { + std::cout << vd[i] << std::endl; + } + try { + std::cout << vd.at(100) << std::endl; + } catch(...) { + std::cout << "exceptions thrown correctly." << std::endl; + } +} + +void TestPush_Pop() +{ + std::cout << "Testing push_back and pop_back..." << std::endl; + sjtu::vector vd; + for (double i = 0.0; i < 10.0; i += 1.0) { + vd.push_back(i); + } + std::cout << vd.back() << std::endl; + for (double i = 20.0; i < 23.0; i += 1.0) { + vd.push_back(i); + } + std::cout << vd.back() << std::endl; + vd.pop_back(); + std::cout << vd.back() << std::endl; + vd.pop_back(); + std::cout << vd.back() << std::endl; + for (int i = 0; i < 5; ++i) { + vd.pop_back(); + } + std::cout << vd.back() << std::endl; +} + +void TestInsert() +{ + std::cout << "Testing insert functions" << std::endl; + sjtu::vector v; + for (int i = 0; i < 10; ++i) { + v.push_back(i); + } + v.insert(v.begin() + 3, 100); + v.insert(v.begin() + 5, 200); + for (sjtu::vector::iterator it = v.begin(); it != v.end(); ++it) { + std::cout << *it << " "; + } + std::cout << std::endl; +} + +void TestErase() +{ + std::cout << "Testing erase functions" << std::endl; + sjtu::vector v; + for (int i = 0; i < 10; ++i) { + v.push_back(i); + } + v.insert(v.begin() + 3, 100); + v.insert(v.begin() + 5, 200); + v.erase(v.begin() + 5); + v.erase(v.begin() + 3); + for (sjtu::vector::iterator it = v.begin(); it != v.end(); ++it) { + std::cout << *it << " "; + } + std::cout << std::endl; +} + +int main(int argc, char const *argv[]) +{ + TestConstructor(); + TestIterators(); + TestAccessingMethod(); + TestPush_Pop(); + TestInsert(); + TestErase(); + return 0; +} \ No newline at end of file diff --git a/vector/data/one/answer.txt b/vector/data/one/answer.txt new file mode 100644 index 0000000..f400511 --- /dev/null +++ b/vector/data/one/answer.txt @@ -0,0 +1,69 @@ +Testing constructors and assignment operator... +1 2 3 4 5 6 7 8 9 10 +0 1 2 3 4 5 6 7 8 9 +1 2 3 4 5 6 7 8 9 10 +Testing iterators... +1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 +1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 +Testing accessing methods... +1 +2 +4 +8 +16 +32 +64 +128 +256 +512 +1024 +2048 +4096 +8192 +16384 +32768 +65536 +131072 +262144 +524288 +1048576 +2097152 +4194304 +8388608 +16777216 +33554432 +67108864 +134217728 +268435456 +536870912 +1073741824 +2147483648 +4294967296 +8589934592 +17179869184 +34359738368 +68719476736 +137438953472 +274877906944 +549755813888 +1099511627776 +2199023255552 +4398046511104 +8796093022208 +17592186044416 +35184372088832 +70368744177664 +140737488355328 +281474976710656 +562949953421312 +exceptions thrown correctly. +Testing push_back and pop_back... +9 +22 +21 +20 +5 +Testing insert functions +0 1 2 100 3 200 4 5 6 7 8 9 +Testing erase functions +0 1 2 3 4 5 6 7 8 9 diff --git a/vector/data/one/code.cpp b/vector/data/one/code.cpp new file mode 100644 index 0000000..4360888 --- /dev/null +++ b/vector/data/one/code.cpp @@ -0,0 +1,132 @@ +#include "vector.hpp" + +#include +#include +#include + +void TestConstructor() +{ + std::cout << "Testing constructors and assignment operator..." << std::endl; + sjtu::vector v; + for (int i = 1; i <= 10; ++i) { + v.push_back(i); + } + const sjtu::vector vc(v); + for (size_t i = 0; i < vc.size(); ++i) { + std::cout << vc[i] << " "; + } + std::cout << std::endl; + sjtu::vector vv; + for (int i = 0; i < 10; ++i) { + vv.push_back(i); + } + for (size_t i = 0; i < vv.size(); ++i) { + std::cout << vv[i] << " "; + } + std::cout << std::endl; + vv = v; + for (size_t i = 0; i < vv.size(); ++i) { + std::cout << vv[i] << " "; + } + std::cout << std::endl; +} + +void TestIterators() +{ + std::cout << "Testing iterators..." << std::endl; + sjtu::vector v; + for (int i = 1; i <= 20; ++i) { + v.push_back(i); + } + for (sjtu::vector::iterator it = v.begin(); it != v.end(); ++it) { + std::cout << *it << " "; + } + std::cout << std::endl; + const sjtu::vector vc(v); + for (sjtu::vector::const_iterator it = vc.cbegin(); it != vc.cend(); ++it) { + std::cout << *it << " "; + } + std::cout << std::endl; +} + +void TestAccessingMethod() +{ + std::cout << "Testing accessing methods..." << std::endl; + sjtu::vector vd; + for (long long i = 0; i < 50; ++i) { + vd.push_back(1LL << i); + } + for (size_t i = 0; i < vd.size(); ++i) { + std::cout << vd[i] << std::endl; + } + try { + std::cout << vd.at(100) << std::endl; + } catch(...) { + std::cout << "exceptions thrown correctly." << std::endl; + } +} + +void TestPush_Pop() +{ + std::cout << "Testing push_back and pop_back..." << std::endl; + sjtu::vector vd; + for (double i = 0.0; i < 10.0; i += 1.0) { + vd.push_back(i); + } + std::cout << vd.back() << std::endl; + for (double i = 20.0; i < 23.0; i += 1.0) { + vd.push_back(i); + } + std::cout << vd.back() << std::endl; + vd.pop_back(); + std::cout << vd.back() << std::endl; + vd.pop_back(); + std::cout << vd.back() << std::endl; + for (int i = 0; i < 5; ++i) { + vd.pop_back(); + } + std::cout << vd.back() << std::endl; +} + +void TestInsert() +{ + std::cout << "Testing insert functions" << std::endl; + sjtu::vector v; + for (int i = 0; i < 10; ++i) { + v.push_back(i); + } + v.insert(v.begin() + 3, 100); + v.insert(v.begin() + 5, 200); + for (sjtu::vector::iterator it = v.begin(); it != v.end(); ++it) { + std::cout << *it << " "; + } + std::cout << std::endl; +} + +void TestErase() +{ + std::cout << "Testing erase functions" << std::endl; + sjtu::vector v; + for (int i = 0; i < 10; ++i) { + v.push_back(i); + } + v.insert(v.begin() + 3, 100); + v.insert(v.begin() + 5, 200); + v.erase(v.begin() + 5); + v.erase(v.begin() + 3); + for (sjtu::vector::iterator it = v.begin(); it != v.end(); ++it) { + std::cout << *it << " "; + } + std::cout << std::endl; +} + +int main(int argc, char const *argv[]) +{ + TestConstructor(); + TestIterators(); + TestAccessingMethod(); + TestPush_Pop(); + TestInsert(); + TestErase(); + return 0; +} \ No newline at end of file diff --git a/vector/data/three.memcheck/answer.txt b/vector/data/three.memcheck/answer.txt new file mode 100644 index 0000000..73001e7 --- /dev/null +++ b/vector/data/three.memcheck/answer.txt @@ -0,0 +1,80 @@ +Test for classes without default constructor... +Test OK... +Test for my Matrix... + + 1.00000000 + + + 2.00000000 2.00000000 + 2.00000000 2.00000000 + + + 3.00000000 3.00000000 3.00000000 + 3.00000000 3.00000000 3.00000000 + 3.00000000 3.00000000 3.00000000 + + + 4.00000000 4.00000000 4.00000000 4.00000000 + 4.00000000 4.00000000 4.00000000 4.00000000 + 4.00000000 4.00000000 4.00000000 4.00000000 + 4.00000000 4.00000000 4.00000000 4.00000000 + + + 5.00000000 5.00000000 5.00000000 5.00000000 5.00000000 + 5.00000000 5.00000000 5.00000000 5.00000000 5.00000000 + 5.00000000 5.00000000 5.00000000 5.00000000 5.00000000 + 5.00000000 5.00000000 5.00000000 5.00000000 5.00000000 + 5.00000000 5.00000000 5.00000000 5.00000000 5.00000000 + + + 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 + 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 + 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 + 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 + 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 + 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 + + + 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 + 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 + 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 + 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 + 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 + 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 + 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 + + + 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 + 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 + 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 + 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 + 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 + 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 + 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 + 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 + + + 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 + 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 + 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 + 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 + 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 + 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 + 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 + 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 + 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 + + + 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 + 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 + 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 + 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 + 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 + 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 + 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 + 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 + 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 + 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 + +Test for big integer +1267650600228229401496703205376 1267650600228231653296516890625 1267650600228233905096330575876 1267650600228236156896144261129 1267650600228238408695957946384 1267650600228240660495771631641 1267650600228242912295585316900 1267650600228245164095399002161 1267650600228247415895212687424 1267650600228249667695026372689 diff --git a/vector/data/three.memcheck/code.cpp b/vector/data/three.memcheck/code.cpp new file mode 100644 index 0000000..ccad51a --- /dev/null +++ b/vector/data/three.memcheck/code.cpp @@ -0,0 +1,51 @@ +#include "vector.hpp" + +#include "class-integer.hpp" +#include "class-matrix.hpp" +#include "class-bint.hpp" + +#include +#include +#include + +void TestInteger() +{ + std::cout << "Test for classes without default constructor..." << std::endl; + sjtu::vector vInt; + for (int i = 1; i <= 100; ++i) { + vInt.push_back(Integer(i)); + } + std::cout << "Test OK..." << std::endl; +} + +void TestMatrix() +{ + std::cout << "Test for my Matrix..." << std::endl; + sjtu::vector> vM; + for (int i = 1; i <= 10; ++i) { + vM.push_back(Diamond::Matrix(i, i, i)); + } + for (size_t i = 0; i < vM.size(); ++i) { + std::cout << vM[i] << std::endl; + } +} + +void TestBint() +{ + std::cout << "Test for big integer" << std::endl; + sjtu::vector vBint; + for (long long i = 1LL << 50; i < (1LL << 50) + 10; ++i) { + vBint.push_back(Util::Bint(i) * i); + } + for (sjtu::vector::iterator it = vBint.begin(); it != vBint.end(); ++it) { + std::cout << *it << " "; + } + std::cout << std::endl; +} + +int main() +{ + TestInteger(); + TestMatrix(); + TestBint(); +} \ No newline at end of file diff --git a/vector/data/three/answer.txt b/vector/data/three/answer.txt new file mode 100644 index 0000000..73001e7 --- /dev/null +++ b/vector/data/three/answer.txt @@ -0,0 +1,80 @@ +Test for classes without default constructor... +Test OK... +Test for my Matrix... + + 1.00000000 + + + 2.00000000 2.00000000 + 2.00000000 2.00000000 + + + 3.00000000 3.00000000 3.00000000 + 3.00000000 3.00000000 3.00000000 + 3.00000000 3.00000000 3.00000000 + + + 4.00000000 4.00000000 4.00000000 4.00000000 + 4.00000000 4.00000000 4.00000000 4.00000000 + 4.00000000 4.00000000 4.00000000 4.00000000 + 4.00000000 4.00000000 4.00000000 4.00000000 + + + 5.00000000 5.00000000 5.00000000 5.00000000 5.00000000 + 5.00000000 5.00000000 5.00000000 5.00000000 5.00000000 + 5.00000000 5.00000000 5.00000000 5.00000000 5.00000000 + 5.00000000 5.00000000 5.00000000 5.00000000 5.00000000 + 5.00000000 5.00000000 5.00000000 5.00000000 5.00000000 + + + 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 + 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 + 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 + 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 + 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 + 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 6.00000000 + + + 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 + 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 + 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 + 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 + 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 + 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 + 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 7.00000000 + + + 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 + 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 + 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 + 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 + 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 + 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 + 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 + 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 8.00000000 + + + 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 + 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 + 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 + 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 + 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 + 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 + 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 + 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 + 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 9.00000000 + + + 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 + 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 + 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 + 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 + 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 + 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 + 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 + 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 + 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 + 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 10.00000000 + +Test for big integer +1267650600228229401496703205376 1267650600228231653296516890625 1267650600228233905096330575876 1267650600228236156896144261129 1267650600228238408695957946384 1267650600228240660495771631641 1267650600228242912295585316900 1267650600228245164095399002161 1267650600228247415895212687424 1267650600228249667695026372689 diff --git a/vector/data/three/code.cpp b/vector/data/three/code.cpp new file mode 100644 index 0000000..ccad51a --- /dev/null +++ b/vector/data/three/code.cpp @@ -0,0 +1,51 @@ +#include "vector.hpp" + +#include "class-integer.hpp" +#include "class-matrix.hpp" +#include "class-bint.hpp" + +#include +#include +#include + +void TestInteger() +{ + std::cout << "Test for classes without default constructor..." << std::endl; + sjtu::vector vInt; + for (int i = 1; i <= 100; ++i) { + vInt.push_back(Integer(i)); + } + std::cout << "Test OK..." << std::endl; +} + +void TestMatrix() +{ + std::cout << "Test for my Matrix..." << std::endl; + sjtu::vector> vM; + for (int i = 1; i <= 10; ++i) { + vM.push_back(Diamond::Matrix(i, i, i)); + } + for (size_t i = 0; i < vM.size(); ++i) { + std::cout << vM[i] << std::endl; + } +} + +void TestBint() +{ + std::cout << "Test for big integer" << std::endl; + sjtu::vector vBint; + for (long long i = 1LL << 50; i < (1LL << 50) + 10; ++i) { + vBint.push_back(Util::Bint(i) * i); + } + for (sjtu::vector::iterator it = vBint.begin(); it != vBint.end(); ++it) { + std::cout << *it << " "; + } + std::cout << std::endl; +} + +int main() +{ + TestInteger(); + TestMatrix(); + TestBint(); +} \ No newline at end of file diff --git a/vector/data/two.memcheck/answer.txt b/vector/data/two.memcheck/answer.txt new file mode 100644 index 0000000..0042761 --- /dev/null +++ b/vector/data/two.memcheck/answer.txt @@ -0,0 +1,1025 @@ +1023 +1023 +1022 +1021 +1020 +1019 +1018 +1017 +1016 +1015 +1014 +1013 +1012 +1011 +1010 +1009 +1008 +1007 +1006 +1005 +1004 +1003 +1002 +1001 +1000 +999 +998 +997 +996 +995 +994 +993 +992 +991 +990 +989 +988 +987 +986 +985 +984 +983 +982 +981 +980 +979 +978 +977 +976 +975 +974 +973 +972 +971 +970 +969 +968 +967 +966 +965 +964 +963 +962 +961 +960 +959 +958 +957 +956 +955 +954 +953 +952 +951 +950 +949 +948 +947 +946 +945 +944 +943 +942 +941 +940 +939 +938 +937 +936 +935 +934 +933 +932 +931 +930 +929 +928 +927 +926 +925 +924 +923 +922 +921 +920 +919 +918 +917 +916 +915 +914 +913 +912 +911 +910 +909 +908 +907 +906 +905 +904 +903 +902 +901 +900 +899 +898 +897 +896 +895 +894 +893 +892 +891 +890 +889 +888 +887 +886 +885 +884 +883 +882 +881 +880 +879 +878 +877 +876 +875 +874 +873 +872 +871 +870 +869 +868 +867 +866 +865 +864 +863 +862 +861 +860 +859 +858 +857 +856 +855 +854 +853 +852 +851 +850 +849 +848 +847 +846 +845 +844 +843 +842 +841 +840 +839 +838 +837 +836 +835 +834 +833 +832 +831 +830 +829 +828 +827 +826 +825 +824 +823 +822 +821 +820 +819 +818 +817 +816 +815 +814 +813 +812 +811 +810 +809 +808 +807 +806 +805 +804 +803 +802 +801 +800 +799 +798 +797 +796 +795 +794 +793 +792 +791 +790 +789 +788 +787 +786 +785 +784 +783 +782 +781 +780 +779 +778 +777 +776 +775 +774 +773 +772 +771 +770 +769 +768 +767 +766 +765 +764 +763 +762 +761 +760 +759 +758 +757 +756 +755 +754 +753 +752 +751 +750 +749 +748 +747 +746 +745 +744 +743 +742 +741 +740 +739 +738 +737 +736 +735 +734 +733 +732 +731 +730 +729 +728 +727 +726 +725 +724 +723 +722 +721 +720 +719 +718 +717 +716 +715 +714 +713 +712 +711 +710 +709 +708 +707 +706 +705 +704 +703 +702 +701 +700 +699 +698 +697 +696 +695 +694 +693 +692 +691 +690 +689 +688 +687 +686 +685 +684 +683 +682 +681 +680 +679 +678 +677 +676 +675 +674 +673 +672 +671 +670 +669 +668 +667 +666 +665 +664 +663 +662 +661 +660 +659 +658 +657 +656 +655 +654 +653 +652 +651 +650 +649 +648 +647 +646 +645 +644 +643 +642 +641 +640 +639 +638 +637 +636 +635 +634 +633 +632 +631 +630 +629 +628 +627 +626 +625 +624 +623 +622 +621 +620 +619 +618 +617 +616 +615 +614 +613 +612 +611 +610 +609 +608 +607 +606 +605 +604 +603 +602 +601 +600 +599 +598 +597 +596 +595 +594 +593 +592 +591 +590 +589 +588 +587 +586 +585 +584 +583 +582 +581 +580 +579 +578 +577 +576 +575 +574 +573 +572 +571 +570 +569 +568 +567 +566 +565 +564 +563 +562 +561 +560 +559 +558 +557 +556 +555 +554 +553 +552 +551 +550 +549 +548 +547 +546 +545 +544 +543 +542 +541 +540 +539 +538 +537 +536 +535 +534 +533 +532 +531 +530 +529 +528 +527 +526 +525 +524 +523 +522 +521 +520 +519 +518 +517 +516 +515 +514 +513 +512 +511 +510 +509 +508 +507 +506 +505 +504 +503 +502 +501 +500 +499 +498 +497 +496 +495 +494 +493 +492 +491 +490 +489 +488 +487 +486 +485 +484 +483 +482 +481 +480 +479 +478 +477 +476 +475 +474 +473 +472 +471 +470 +469 +468 +467 +466 +465 +464 +463 +462 +461 +460 +459 +458 +457 +456 +455 +454 +453 +452 +451 +450 +449 +448 +447 +446 +445 +444 +443 +442 +441 +440 +439 +438 +437 +436 +435 +434 +433 +432 +431 +430 +429 +428 +427 +426 +425 +424 +423 +422 +421 +420 +419 +418 +417 +416 +415 +414 +413 +412 +411 +410 +409 +408 +407 +406 +405 +404 +403 +402 +401 +400 +399 +398 +397 +396 +395 +394 +393 +392 +391 +390 +389 +388 +387 +386 +385 +384 +383 +382 +381 +380 +379 +378 +377 +376 +375 +374 +373 +372 +371 +370 +369 +368 +367 +366 +365 +364 +363 +362 +361 +360 +359 +358 +357 +356 +355 +354 +353 +352 +351 +350 +349 +348 +347 +346 +345 +344 +343 +342 +341 +340 +339 +338 +337 +336 +335 +334 +333 +332 +331 +330 +329 +328 +327 +326 +325 +324 +323 +322 +321 +320 +319 +318 +317 +316 +315 +314 +313 +312 +311 +310 +309 +308 +307 +306 +305 +304 +303 +302 +301 +300 +299 +298 +297 +296 +295 +294 +293 +292 +291 +290 +289 +288 +287 +286 +285 +284 +283 +282 +281 +280 +279 +278 +277 +276 +275 +274 +273 +272 +271 +270 +269 +268 +267 +266 +265 +264 +263 +262 +261 +260 +259 +258 +257 +256 +255 +254 +253 +252 +251 +250 +249 +248 +247 +246 +245 +244 +243 +242 +241 +240 +239 +238 +237 +236 +235 +234 +233 +232 +231 +230 +229 +228 +227 +226 +225 +224 +223 +222 +221 +220 +219 +218 +217 +216 +215 +214 +213 +212 +211 +210 +209 +208 +207 +206 +205 +204 +203 +202 +201 +200 +199 +198 +197 +196 +195 +194 +193 +192 +191 +190 +189 +188 +187 +186 +185 +184 +183 +182 +181 +180 +179 +178 +177 +176 +175 +174 +173 +172 +171 +170 +169 +168 +167 +166 +165 +164 +163 +162 +161 +160 +159 +158 +157 +156 +155 +154 +153 +152 +151 +150 +149 +148 +147 +146 +145 +144 +143 +142 +141 +140 +139 +138 +137 +136 +135 +134 +133 +132 +131 +130 +129 +128 +127 +126 +125 +124 +123 +122 +121 +120 +119 +118 +117 +116 +115 +114 +113 +112 +111 +110 +109 +108 +107 +106 +105 +104 +103 +102 +101 +100 +99 +98 +97 +96 +95 +94 +93 +92 +91 +90 +89 +88 +87 +86 +85 +84 +83 +82 +81 +80 +79 +78 +77 +76 +75 +74 +73 +72 +71 +70 +69 +68 +67 +66 +65 +64 +63 +62 +61 +60 +59 +58 +57 +56 +55 +54 +53 +52 +51 +50 +49 +48 +47 +46 +45 +44 +43 +42 +41 +40 +39 +38 +37 +36 +35 +34 +33 +32 +31 +30 +29 +28 +27 +26 +25 +24 +23 +22 +21 +20 +19 +18 +17 +16 +15 +14 +13 +12 +11 +10 +9 +8 +7 +6 +5 +4 +3 +2 +1 +0 diff --git a/vector/data/two.memcheck/code.cpp b/vector/data/two.memcheck/code.cpp new file mode 100644 index 0000000..4276614 --- /dev/null +++ b/vector/data/two.memcheck/code.cpp @@ -0,0 +1,22 @@ +#include "vector.hpp" + +#include + +#include + +int main() +{ + sjtu::vector v; + for (long long i = 0; i < 1LL << 10; ++i) { + v.push_back(i); + } + std::cout << v.back() << std::endl; + for (long long i = 0; i < 1LL << 10; ++i) { + v.insert(v.begin(), i); + } + for (size_t i = 0; i < 1LL << 10; ++i) { + std::cout << v.front() << std::endl; + v.erase(v.begin()); + } + return 0; +} diff --git a/vector/data/two/answer.txt b/vector/data/two/answer.txt new file mode 100644 index 0000000..0d45f3b --- /dev/null +++ b/vector/data/two/answer.txt @@ -0,0 +1,1025 @@ +1048575 +2047 +2046 +2045 +2044 +2043 +2042 +2041 +2040 +2039 +2038 +2037 +2036 +2035 +2034 +2033 +2032 +2031 +2030 +2029 +2028 +2027 +2026 +2025 +2024 +2023 +2022 +2021 +2020 +2019 +2018 +2017 +2016 +2015 +2014 +2013 +2012 +2011 +2010 +2009 +2008 +2007 +2006 +2005 +2004 +2003 +2002 +2001 +2000 +1999 +1998 +1997 +1996 +1995 +1994 +1993 +1992 +1991 +1990 +1989 +1988 +1987 +1986 +1985 +1984 +1983 +1982 +1981 +1980 +1979 +1978 +1977 +1976 +1975 +1974 +1973 +1972 +1971 +1970 +1969 +1968 +1967 +1966 +1965 +1964 +1963 +1962 +1961 +1960 +1959 +1958 +1957 +1956 +1955 +1954 +1953 +1952 +1951 +1950 +1949 +1948 +1947 +1946 +1945 +1944 +1943 +1942 +1941 +1940 +1939 +1938 +1937 +1936 +1935 +1934 +1933 +1932 +1931 +1930 +1929 +1928 +1927 +1926 +1925 +1924 +1923 +1922 +1921 +1920 +1919 +1918 +1917 +1916 +1915 +1914 +1913 +1912 +1911 +1910 +1909 +1908 +1907 +1906 +1905 +1904 +1903 +1902 +1901 +1900 +1899 +1898 +1897 +1896 +1895 +1894 +1893 +1892 +1891 +1890 +1889 +1888 +1887 +1886 +1885 +1884 +1883 +1882 +1881 +1880 +1879 +1878 +1877 +1876 +1875 +1874 +1873 +1872 +1871 +1870 +1869 +1868 +1867 +1866 +1865 +1864 +1863 +1862 +1861 +1860 +1859 +1858 +1857 +1856 +1855 +1854 +1853 +1852 +1851 +1850 +1849 +1848 +1847 +1846 +1845 +1844 +1843 +1842 +1841 +1840 +1839 +1838 +1837 +1836 +1835 +1834 +1833 +1832 +1831 +1830 +1829 +1828 +1827 +1826 +1825 +1824 +1823 +1822 +1821 +1820 +1819 +1818 +1817 +1816 +1815 +1814 +1813 +1812 +1811 +1810 +1809 +1808 +1807 +1806 +1805 +1804 +1803 +1802 +1801 +1800 +1799 +1798 +1797 +1796 +1795 +1794 +1793 +1792 +1791 +1790 +1789 +1788 +1787 +1786 +1785 +1784 +1783 +1782 +1781 +1780 +1779 +1778 +1777 +1776 +1775 +1774 +1773 +1772 +1771 +1770 +1769 +1768 +1767 +1766 +1765 +1764 +1763 +1762 +1761 +1760 +1759 +1758 +1757 +1756 +1755 +1754 +1753 +1752 +1751 +1750 +1749 +1748 +1747 +1746 +1745 +1744 +1743 +1742 +1741 +1740 +1739 +1738 +1737 +1736 +1735 +1734 +1733 +1732 +1731 +1730 +1729 +1728 +1727 +1726 +1725 +1724 +1723 +1722 +1721 +1720 +1719 +1718 +1717 +1716 +1715 +1714 +1713 +1712 +1711 +1710 +1709 +1708 +1707 +1706 +1705 +1704 +1703 +1702 +1701 +1700 +1699 +1698 +1697 +1696 +1695 +1694 +1693 +1692 +1691 +1690 +1689 +1688 +1687 +1686 +1685 +1684 +1683 +1682 +1681 +1680 +1679 +1678 +1677 +1676 +1675 +1674 +1673 +1672 +1671 +1670 +1669 +1668 +1667 +1666 +1665 +1664 +1663 +1662 +1661 +1660 +1659 +1658 +1657 +1656 +1655 +1654 +1653 +1652 +1651 +1650 +1649 +1648 +1647 +1646 +1645 +1644 +1643 +1642 +1641 +1640 +1639 +1638 +1637 +1636 +1635 +1634 +1633 +1632 +1631 +1630 +1629 +1628 +1627 +1626 +1625 +1624 +1623 +1622 +1621 +1620 +1619 +1618 +1617 +1616 +1615 +1614 +1613 +1612 +1611 +1610 +1609 +1608 +1607 +1606 +1605 +1604 +1603 +1602 +1601 +1600 +1599 +1598 +1597 +1596 +1595 +1594 +1593 +1592 +1591 +1590 +1589 +1588 +1587 +1586 +1585 +1584 +1583 +1582 +1581 +1580 +1579 +1578 +1577 +1576 +1575 +1574 +1573 +1572 +1571 +1570 +1569 +1568 +1567 +1566 +1565 +1564 +1563 +1562 +1561 +1560 +1559 +1558 +1557 +1556 +1555 +1554 +1553 +1552 +1551 +1550 +1549 +1548 +1547 +1546 +1545 +1544 +1543 +1542 +1541 +1540 +1539 +1538 +1537 +1536 +1535 +1534 +1533 +1532 +1531 +1530 +1529 +1528 +1527 +1526 +1525 +1524 +1523 +1522 +1521 +1520 +1519 +1518 +1517 +1516 +1515 +1514 +1513 +1512 +1511 +1510 +1509 +1508 +1507 +1506 +1505 +1504 +1503 +1502 +1501 +1500 +1499 +1498 +1497 +1496 +1495 +1494 +1493 +1492 +1491 +1490 +1489 +1488 +1487 +1486 +1485 +1484 +1483 +1482 +1481 +1480 +1479 +1478 +1477 +1476 +1475 +1474 +1473 +1472 +1471 +1470 +1469 +1468 +1467 +1466 +1465 +1464 +1463 +1462 +1461 +1460 +1459 +1458 +1457 +1456 +1455 +1454 +1453 +1452 +1451 +1450 +1449 +1448 +1447 +1446 +1445 +1444 +1443 +1442 +1441 +1440 +1439 +1438 +1437 +1436 +1435 +1434 +1433 +1432 +1431 +1430 +1429 +1428 +1427 +1426 +1425 +1424 +1423 +1422 +1421 +1420 +1419 +1418 +1417 +1416 +1415 +1414 +1413 +1412 +1411 +1410 +1409 +1408 +1407 +1406 +1405 +1404 +1403 +1402 +1401 +1400 +1399 +1398 +1397 +1396 +1395 +1394 +1393 +1392 +1391 +1390 +1389 +1388 +1387 +1386 +1385 +1384 +1383 +1382 +1381 +1380 +1379 +1378 +1377 +1376 +1375 +1374 +1373 +1372 +1371 +1370 +1369 +1368 +1367 +1366 +1365 +1364 +1363 +1362 +1361 +1360 +1359 +1358 +1357 +1356 +1355 +1354 +1353 +1352 +1351 +1350 +1349 +1348 +1347 +1346 +1345 +1344 +1343 +1342 +1341 +1340 +1339 +1338 +1337 +1336 +1335 +1334 +1333 +1332 +1331 +1330 +1329 +1328 +1327 +1326 +1325 +1324 +1323 +1322 +1321 +1320 +1319 +1318 +1317 +1316 +1315 +1314 +1313 +1312 +1311 +1310 +1309 +1308 +1307 +1306 +1305 +1304 +1303 +1302 +1301 +1300 +1299 +1298 +1297 +1296 +1295 +1294 +1293 +1292 +1291 +1290 +1289 +1288 +1287 +1286 +1285 +1284 +1283 +1282 +1281 +1280 +1279 +1278 +1277 +1276 +1275 +1274 +1273 +1272 +1271 +1270 +1269 +1268 +1267 +1266 +1265 +1264 +1263 +1262 +1261 +1260 +1259 +1258 +1257 +1256 +1255 +1254 +1253 +1252 +1251 +1250 +1249 +1248 +1247 +1246 +1245 +1244 +1243 +1242 +1241 +1240 +1239 +1238 +1237 +1236 +1235 +1234 +1233 +1232 +1231 +1230 +1229 +1228 +1227 +1226 +1225 +1224 +1223 +1222 +1221 +1220 +1219 +1218 +1217 +1216 +1215 +1214 +1213 +1212 +1211 +1210 +1209 +1208 +1207 +1206 +1205 +1204 +1203 +1202 +1201 +1200 +1199 +1198 +1197 +1196 +1195 +1194 +1193 +1192 +1191 +1190 +1189 +1188 +1187 +1186 +1185 +1184 +1183 +1182 +1181 +1180 +1179 +1178 +1177 +1176 +1175 +1174 +1173 +1172 +1171 +1170 +1169 +1168 +1167 +1166 +1165 +1164 +1163 +1162 +1161 +1160 +1159 +1158 +1157 +1156 +1155 +1154 +1153 +1152 +1151 +1150 +1149 +1148 +1147 +1146 +1145 +1144 +1143 +1142 +1141 +1140 +1139 +1138 +1137 +1136 +1135 +1134 +1133 +1132 +1131 +1130 +1129 +1128 +1127 +1126 +1125 +1124 +1123 +1122 +1121 +1120 +1119 +1118 +1117 +1116 +1115 +1114 +1113 +1112 +1111 +1110 +1109 +1108 +1107 +1106 +1105 +1104 +1103 +1102 +1101 +1100 +1099 +1098 +1097 +1096 +1095 +1094 +1093 +1092 +1091 +1090 +1089 +1088 +1087 +1086 +1085 +1084 +1083 +1082 +1081 +1080 +1079 +1078 +1077 +1076 +1075 +1074 +1073 +1072 +1071 +1070 +1069 +1068 +1067 +1066 +1065 +1064 +1063 +1062 +1061 +1060 +1059 +1058 +1057 +1056 +1055 +1054 +1053 +1052 +1051 +1050 +1049 +1048 +1047 +1046 +1045 +1044 +1043 +1042 +1041 +1040 +1039 +1038 +1037 +1036 +1035 +1034 +1033 +1032 +1031 +1030 +1029 +1028 +1027 +1026 +1025 +1024 diff --git a/vector/data/two/code.cpp b/vector/data/two/code.cpp new file mode 100644 index 0000000..68d2ffa --- /dev/null +++ b/vector/data/two/code.cpp @@ -0,0 +1,22 @@ +#include "vector.hpp" + +#include + +#include + +int main() +{ + sjtu::vector v; + for (long long i = 0; i < 1LL << 20; ++i) { + v.push_back(i); + } + std::cout << v.back() << std::endl; + for (long long i = 0; i < 1LL << 11; ++i) { + v.insert(v.begin(), i); + } + for (size_t i = 0; i < 1LL << 10; ++i) { + std::cout << v.front() << std::endl; + v.erase(v.begin()); + } + return 0; +} \ No newline at end of file diff --git a/vector/src/exceptions.hpp b/vector/src/exceptions.hpp new file mode 100644 index 0000000..183eb41 --- /dev/null +++ b/vector/src/exceptions.hpp @@ -0,0 +1,39 @@ +#ifndef SJTU_EXCEPTIONS_HPP +#define SJTU_EXCEPTIONS_HPP + +#include +#include +#include + +namespace sjtu { + +class exception { +protected: + const std::string variant = ""; + std::string detail = ""; +public: + exception() {} + exception(const exception &ec) : variant(ec.variant), detail(ec.detail) {} + virtual std::string what() { + return variant + " " + detail; + } +}; + +class index_out_of_bound : public exception { + /* __________________________ */ +}; + +class runtime_error : public exception { + /* __________________________ */ +}; + +class invalid_iterator : public exception { + /* __________________________ */ +}; + +class container_is_empty : public exception { + /* __________________________ */ +}; +} + +#endif diff --git a/vector/src/utility.hpp b/vector/src/utility.hpp new file mode 100644 index 0000000..4d13ee5 --- /dev/null +++ b/vector/src/utility.hpp @@ -0,0 +1,27 @@ +#ifndef SJTU_UTILITY_HPP +#define SJTU_UTILITY_HPP + +#include + +namespace sjtu { + +template +class pair { +public: + T1 first; + T2 second; + constexpr pair() : first(), second() {} + pair(const pair &other) = default; + pair(pair &&other) = default; + pair(const T1 &x, const T2 &y) : first(x), second(y) {} + template + pair(U1 &&x, U2 &&y) : first(x), second(y) {} + template + pair(const pair &other) : first(other.first), second(other.second) {} + template + pair(pair &&other) : first(other.first), second(other.second) {} +}; + +} + +#endif diff --git a/vector/src/vector.hpp b/vector/src/vector.hpp new file mode 100644 index 0000000..6206c74 --- /dev/null +++ b/vector/src/vector.hpp @@ -0,0 +1,226 @@ +#ifndef SJTU_VECTOR_HPP +#define SJTU_VECTOR_HPP + +#include "exceptions.hpp" + +#include +#include + +namespace sjtu +{ +/** + * a data container like std::vector + * store data in a successive memory and support random access. + */ +template +class vector +{ +public: + /** + * TODO + * a type for actions of the elements of a vector, and you should write + * a class named const_iterator with same interfaces. + */ + /** + * you can see RandomAccessIterator at CppReference for help. + */ + class const_iterator; + class iterator + { + // The following code is written for the C++ type_traits library. + // Type traits is a C++ feature for describing certain properties of a type. + // For instance, for an iterator, iterator::value_type is the type that the + // iterator points to. + // STL algorithms and containers may use these type_traits (e.g. the following + // typedef) to work properly. In particular, without the following code, + // @code{std::sort(iter, iter1);} would not compile. + // See these websites for more information: + // https://en.cppreference.com/w/cpp/header/type_traits + // About value_type: https://blog.csdn.net/u014299153/article/details/72419713 + // About iterator_category: https://en.cppreference.com/w/cpp/iterator + public: + using difference_type = std::ptrdiff_t; + using value_type = T; + using pointer = T*; + using reference = T&; + using iterator_category = std::output_iterator_tag; + + private: + /** + * TODO add data members + * just add whatever you want. + */ + public: + /** + * return a new iterator which pointer n-next elements + * as well as operator- + */ + iterator operator+(const int &n) const + { + //TODO + } + iterator operator-(const int &n) const + { + //TODO + } + // return the distance between two iterators, + // if these two iterators point to different vectors, throw invaild_iterator. + int operator-(const iterator &rhs) const + { + //TODO + } + iterator& operator+=(const int &n) + { + //TODO + } + iterator& operator-=(const int &n) + { + //TODO + } + /** + * TODO iter++ + */ + iterator operator++(int) {} + /** + * TODO ++iter + */ + iterator& operator++() {} + /** + * TODO iter-- + */ + iterator operator--(int) {} + /** + * TODO --iter + */ + iterator& operator--() {} + /** + * TODO *it + */ + T& operator*() const{} + /** + * a operator to check whether two iterators are same (pointing to the same memory address). + */ + bool operator==(const iterator &rhs) const {} + bool operator==(const const_iterator &rhs) const {} + /** + * some other operator for iterator. + */ + bool operator!=(const iterator &rhs) const {} + bool operator!=(const const_iterator &rhs) const {} + }; + /** + * TODO + * has same function as iterator, just for a const object. + */ + class const_iterator + { + public: + using difference_type = std::ptrdiff_t; + using value_type = T; + using pointer = T*; + using reference = T&; + using iterator_category = std::output_iterator_tag; + + private: + /*TODO*/ + + }; + /** + * TODO Constructs + * At least two: default constructor, copy constructor + */ + vector() {} + vector(const vector &other) {} + /** + * TODO Destructor + */ + ~vector() {} + /** + * TODO Assignment operator + */ + vector &operator=(const vector &other) {} + /** + * assigns specified element with bounds checking + * throw index_out_of_bound if pos is not in [0, size) + */ + T & at(const size_t &pos) {} + const T & at(const size_t &pos) const {} + /** + * assigns specified element with bounds checking + * throw index_out_of_bound if pos is not in [0, size) + * !!! Pay attentions + * In STL this operator does not check the boundary but I want you to do. + */ + T & operator[](const size_t &pos) {} + const T & operator[](const size_t &pos) const {} + /** + * access the first element. + * throw container_is_empty if size == 0 + */ + const T & front() const {} + /** + * access the last element. + * throw container_is_empty if size == 0 + */ + const T & back() const {} + /** + * returns an iterator to the beginning. + */ + iterator begin() {} + const_iterator cbegin() const {} + /** + * returns an iterator to the end. + */ + iterator end() {} + const_iterator cend() const {} + /** + * checks whether the container is empty + */ + bool empty() const {} + /** + * returns the number of elements + */ + size_t size() const {} + /** + * clears the contents + */ + void clear() {} + /** + * inserts value before pos + * returns an iterator pointing to the inserted value. + */ + iterator insert(iterator pos, const T &value) {} + /** + * inserts value at index ind. + * after inserting, this->at(ind) == value + * returns an iterator pointing to the inserted value. + * throw index_out_of_bound if ind > size (in this situation ind can be size because after inserting the size will increase 1.) + */ + iterator insert(const size_t &ind, const T &value) {} + /** + * removes the element at pos. + * return an iterator pointing to the following element. + * If the iterator pos refers the last element, the end() iterator is returned. + */ + iterator erase(iterator pos) {} + /** + * removes the element with index ind. + * return an iterator pointing to the following element. + * throw index_out_of_bound if ind >= size + */ + iterator erase(const size_t &ind) {} + /** + * adds an element to the end. + */ + void push_back(const T &value) {} + /** + * remove the last element from the end. + * throw container_is_empty if size() == 0 + */ + void pop_back() {} +}; + + +} + +#endif