diff options
author | TravisBot <> | 2017-09-21 23:52:57 +0000 |
---|---|---|
committer | TravisBot <> | 2017-09-21 23:52:57 +0000 |
commit | 43d8d9b5de8f269643c380d8d6c6c65d9224ad4a (patch) | |
tree | b8a9546cb663081e4587f812fa49a228be9978e5 /yage/math | |
parent | ad666428488d3c800ca18d877dad803bf18b8168 (diff) | |
download | YAGE-43d8d9b5de8f269643c380d8d6c6c65d9224ad4a.tar.gz YAGE-43d8d9b5de8f269643c380d8d6c6c65d9224ad4a.zip |
Rebuilding documentation
Diffstat (limited to 'yage/math')
-rw-r--r-- | yage/math/CMakeLists.txt | 1 | ||||
-rw-r--r-- | yage/math/math.h | 14 | ||||
-rw-r--r-- | yage/math/matrix.h | 424 |
3 files changed, 0 insertions, 439 deletions
diff --git a/yage/math/CMakeLists.txt b/yage/math/CMakeLists.txt deleted file mode 100644 index 761ab59f..00000000 --- a/yage/math/CMakeLists.txt +++ /dev/null @@ -1 +0,0 @@ -set(YAGE_MATH_SOURCES) diff --git a/yage/math/math.h b/yage/math/math.h deleted file mode 100644 index b729dbe6..00000000 --- a/yage/math/math.h +++ /dev/null @@ -1,14 +0,0 @@ -/* ---------------------------------------------------------------------------- - * math.h - * - * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License - * See file LICENSE for more details - * ---------------------------------------------------------------------------- - */ - -#ifndef YAGE_MATH_H -#define YAGE_MATH_H - -#include "matrix.h" - -#endif diff --git a/yage/math/matrix.h b/yage/math/matrix.h deleted file mode 100644 index 3df1509d..00000000 --- a/yage/math/matrix.h +++ /dev/null @@ -1,424 +0,0 @@ -/* ---------------------------------------------------------------------------- - * matrix.h - * - * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License - * See file LICENSE for more details - * ---------------------------------------------------------------------------- - */ - -/** @file - */ - -#ifndef YAGE_MATH_MATRIX_H -#define YAGE_MATH_MATRIX_H - -#include <algorithm> -#include <exception> -#include <iostream> -#include <sstream> -#include <string> -#include <vector> - -namespace yage -{ - -template <int Rows, int Cols, class Type> -class Matrix; - -/** @internal Namespace for internal details. - * - * Details Namespace - * ================ - * - * This is the namespace used for implementation details. - */ -namespace details -{ - -/** @internal Internal Row class used by the Matrix class to return the - * internal data structure of the Matrix. - * - * Row - * === - * - * Internal Row class to return a value in the row of the matrix. - */ -template <int Rows, int Cols, class Type> -class Row -{ -private: - Matrix<Rows, Cols, Type> *parent_; - int index_; - -public: - Row<Rows, Cols, Type>(Matrix<Rows, Cols, Type> *parent, int index) - : parent_(parent), index_(index) - { - } - - Type &operator[](int col) - { - // The index is the y-position of the element in the matrix - return parent_->data_[index_ * Cols + col]; - } - - const Type &operator[](int col) const - { - return parent_->data_[index_ * Cols + col]; - } -}; - -} // namespace details - -/** Base Matrix class used by other similar classes. - */ -template <int Rows = 4, int Cols = 4, class Type = double> -class Matrix -{ - // friended with the row class so that it can access protected member data. - friend class details::Row<Rows, Cols, Type>; - -protected: - /// Vector containing the data of the matrix. - std::vector<Type> data_; - -public: - /// Initializes the size of the data_ vector. - Matrix<Rows, Cols, Type>() : data_(Rows * Cols) {} - Matrix<Rows, Cols, Type>(const std::vector<Type> &data) : data_(data) {} - - /// Returns the row size of the Matrix. - int rowSize() const { return Rows; } - - /// Returns the column size of the Matrix. - int colSize() const { return Cols; } - - /** Return the row specified row as a Matrix with only one row. - * - * @param row Row number to be returned. - * @return The row that is specified by the row variables. - */ - Matrix<1, Cols, Type> getRow(int row) const - { - Matrix<1, Cols, Type> rowMatrix; - for (int i = 0; i < Cols; ++i) { - rowMatrix[0][i] = data_[row][i]; - } - return rowMatrix; - } - - /** Get a specific column in a column vector. - * - * @param col Column number to be returned. - * @return Column Matrix of the selected column. - */ - Matrix<Rows, 1, Type> getCol(int col) const - { - Matrix<Rows, 1, Type> colMatrix; - for (int i = 0; i < Rows; ++i) { - colMatrix[i][0] = data_[i][col]; - } - return colMatrix; - } - - /** Iterator support for the start. - * - * @return Iterator pointing to the start of the data. - */ - typename std::vector<Type>::iterator begin() { return data_.begin(); } - - /** Iterator support for the end. - * - * @return Iterator pointing to the end of the data. - */ - typename std::vector<Type>::iterator end() { return data_.end(); } - - /** Prints out the matrix, but can also be implemented by other classes to - * print data differently. - * - * @bug When printing certain matrices, it omits a row or column. Still - * need to determine under which conditions. - */ - virtual std::string toString() const - { - std::stringstream ss; - ss << '['; - for (int i = 0; i < Rows - 1; ++i) { - ss << '['; - for (int j = 0; j < Cols - 1; ++j) { - ss << data_[i * Cols + j] << ' '; - } - ss << data_[(Rows - 1) * Cols + Cols - 1] << "],"; - } - ss << '['; - for (int j = 0; j < Cols - 1; ++j) { - ss << data_[(Rows - 1) * Cols + j] << ' '; - } - ss << data_[(Rows - 1) * Cols + Cols - 1] << "]]"; - return ss.str(); - } - - details::Row<Rows, Cols, Type> operator[](int row) - { - return details::Row<Rows, Cols, Type>(this, row); - } - - details::Row<Rows, Cols, Type> operator[](int row) const - { - return details::Row<Rows, Cols, Type>((Matrix<Rows, Cols, Type> *)this, - row); - } - - Matrix<Rows, Cols, Type> &operator+=(const Matrix<Rows, Cols, Type> &rhs) - { - std::vector<Type> out; - out.reserve(data_.size()); - std::transform(data_.begin(), data_.end(), rhs.data_.begin(), - std::back_inserter(out), - [](Type a, Type b) { return a + b; }); - data_ = std::move(out); - return *this; - } - - Matrix<Rows, Cols, Type> &operator-=(const Matrix<Rows, Cols, Type> &rhs) - { - std::vector<Type> out; - out.reserve(data_.size()); - std::transform(data_.begin(), data_.end(), rhs.begin(), - std::back_inserter(out), - [](Type a, Type b) { return a - b; }); - data_ = std::move(out); - return *this; - } -}; - -template <int M, int N, class T> -Matrix<M, N, T> operator+(Matrix<M, N, T> lhs, const Matrix<M, N, T> &rhs) -{ - lhs += rhs; - return lhs; -} - -template <int M, int N, class T> -Matrix<M, N, T> operator-(Matrix<M, N, T> lhs, const Matrix<M, N, T> &rhs) -{ - lhs -= rhs; - return lhs; -} - -template <int M, int N, class T> -Matrix<M, N, T> operator+(Matrix<M, N, T> lhs, const T &rhs) -{ - for (auto &data : lhs) { - data += rhs; - } - return lhs; -} - -template <int M, int N, class T> -Matrix<M, N, T> operator+(const T &lhs, Matrix<M, N, T> rhs) -{ - for (auto &data : rhs) { - data += lhs; - } - return rhs; -} - -template <int M, int N, class T> -Matrix<M, N, T> operator-(Matrix<M, N, T> lhs, const T &rhs) -{ - for (auto &data : lhs) { - data -= rhs; - } - return lhs; -} - -template <int M, int N, class T> -Matrix<M, N, T> operator-(const T &lhs, Matrix<M, N, T> rhs) -{ - for (auto &data : rhs) { - data = lhs - data; - } - return rhs; -} - -template <int M, int N, class T> -Matrix<M, N, T> operator*(Matrix<M, N, T> lhs, const T &rhs) -{ - for (auto &data : lhs) { - data *= rhs; - } - return lhs; -} - -template <int M, int N, class T> -Matrix<M, N, T> operator*(const T &lhs, Matrix<M, N, T> rhs) -{ - for (auto &data : rhs) { - data *= lhs; - } - return rhs; -} - -template <int M, int N, class T> -Matrix<M, N, T> operator/(Matrix<M, N, T> lhs, const T &rhs) -{ - for (auto &data : lhs) { - data /= rhs; - } - return lhs; -} - -template <int M, int N, class T> -bool operator==(const Matrix<M, N, T> &lhs, const Matrix<M, N, T> &rhs) -{ - for (int i = 0; i < M; ++i) { - for (int j = 0; j < N; ++j) { - if (lhs[i][j] != rhs[i][j]) { - return false; - } - } - } - return true; -} - -template <int M, int N, class T> -std::ostream &operator<<(std::ostream &os, const Matrix<M, N, T> &mat) -{ - return os << mat.toString(); -} - -template <int Rows = 2, class Type = double> -class Vector : public Matrix<Rows, 1, Type> -{ -public: - Vector<Rows, Type>() : Matrix<Rows, 1, Type>() {} - Vector<Rows, Type>(const Matrix<Rows, 1, Type> &other) - : Matrix<Rows, 1, Type>(other) - { - } - - Vector<Rows, Type>(const std::vector<Type> &data) - : Matrix<Rows, 1, Type>(data) - { - } - - Type &operator[](int col) { return this->data_[col]; } - - const Type &operator[](int col) const { return this->data_[col]; } - - std::string toString() const override - { - std::stringstream ss; - ss << "["; - for (std::size_t i = 0; i < this->data_.size() - 1; ++i) { - ss << this->data_[i] << " "; - } - ss << this->data_[this->data_.size() - 1] << "]"; - return ss.str(); - } -}; - -/** 2D Vector class. - * - * Two dimensional vector class. - */ -template <class Type = double> -class Vector2 : public Vector<2, Type> -{ -public: - Vector2<Type>() : Vector<2, Type>() {} - Vector2<Type>(const std::vector<Type> &data) : Vector<2, Type>(data) {} - - Vector2<Type>(Type x, Type y) - { - this->data_[0] = x; - this->data_[1] = y; - } - - Vector2<Type>(const Matrix<2, 1, Type> &other) : Vector<2, Type>(other) {} - - Type &x() { return this->data_[0]; } - - const Type &x() const { return this->data_[0]; } - - Type &y() { return this->data_[1]; } - - const Type &y() const { return this->data_[1]; } -}; - -/** Definition of a 2D vector. - */ -using Vector2d = Vector2<double>; - -/** Namespace containing functions that operate on matrices. - * - * Implementations defined here are meant to operate on anything that inherits - * from the base Matrix class. - */ -namespace matrix -{ - -/** Transposes a matrix and returns the result - * - * @param m input matrix. - */ -template <int M, int N, class T> -Matrix<N, M, T> transpose(const Matrix<M, N, T> &m) -{ - Matrix<N, M, T> trans; - for (int i = 0; i < M; ++i) { - for (int j = 0; j < N; ++j) { - trans[j][i] = m[i][j]; - } - } - return trans; -} - -/** Returns the dot product between two vectors - * - * @param m1,m2 Input matrices. - */ -template <int R, class T> -T dot(const Matrix<R, 1, T> &m1, const Matrix<R, 1, T> &m2) -{ - T sum = 0; - for (int i = 0; i < R; ++i) { - sum += m1[i][0] * m2[i][0]; - } - return sum; -} - -/** Multiplies two matrices together. - * - * @param m1,m2 Matrix inputs - * - * Requires the two matrices to be compatible with multiplication. - */ -template <int M, int N, int P, int Q, class T> -Matrix<M, Q, T> multiply(const Matrix<M, N, T> &m1, const Matrix<P, Q, T> &m2) -{ - /// @todo Think if this should be a static_assert. - if (N != P) { - throw std::runtime_error( - "Matrices don't have the right dimensions for multiplication"); - } - - Matrix<M, Q, T> res; - - /// Performs multiplication by getting the rows and columns, transposing - /// one of them and then doting the result. - for (int i = 0; i < M; ++i) { - for (int j = 0; j < Q; ++j) { - res[i][j] = dot(transpose(m1.getRow(i)), m2.getCol(j)); - } - } - - return res; -} - -} // namespace matrix - -} // namespace yage - -#endif |