From 37dcd66acd33b99286ade24886e296ea16bcdc4a Mon Sep 17 00:00:00 2001 From: kai Date: Thu, 27 Mar 2025 09:01:08 +0100 Subject: [PATCH] add fib cmake project --- lab02/fib/CMakeLists.txt | 13 ++ lab02/fib/include/matrix.h | 340 +++++++++++++++++++++++++++++++++++++ lab02/fib/src/main.cpp | 0 3 files changed, 353 insertions(+) create mode 100644 lab02/fib/CMakeLists.txt create mode 100644 lab02/fib/include/matrix.h create mode 100644 lab02/fib/src/main.cpp diff --git a/lab02/fib/CMakeLists.txt b/lab02/fib/CMakeLists.txt new file mode 100644 index 0000000..3f73fe0 --- /dev/null +++ b/lab02/fib/CMakeLists.txt @@ -0,0 +1,13 @@ +cmake_minimum_required(VERSION 3.10) + +# Projektname +project(fib) + +# C++-Standard setzen +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED True) + +# add includes +include_directories(include) +# Quellverzeichnis angeben +add_executable(MyProject src/main.cpp) diff --git a/lab02/fib/include/matrix.h b/lab02/fib/include/matrix.h new file mode 100644 index 0000000..2e0bd86 --- /dev/null +++ b/lab02/fib/include/matrix.h @@ -0,0 +1,340 @@ +/** + * matrix.h a very simplistic class for m times n matrices. + */ + +#ifndef MATRIX_H +#define MATRIX_H + +#include +#include +#include +#include + +// A very simplistic vector class for vectors of size n +class Vector { +public: + // constructors + Vector(int n) : n_(n), data_(n_, 0) {} + Vector(const Vector &other) = default; + Vector(Vector &&other) = default; + ~Vector() = default; + + // assignment operators + Vector &operator=(const Vector &other) = default; + Vector &operator=(Vector &&other) = default; + + // element access + double &operator()(int i) { return data_[i]; } + const double &operator()(int i) const { return data_[i]; } + + // getter functions for the dimensions + int dim() const { return n_; } + + // comparison operators + bool operator==(const Vector &b) { return (data_ == b.data_); } + bool operator!=(const Vector &b) { return (data_ != b.data_); } + + // addition + Vector &operator+=(const Vector &b) { + for (int i = 0; i < n_; ++i) { + operator()(i) += b(i); + } + return *this; + } + + // subtraction + Vector &operator-=(const Vector &b) { + for (int i = 0; i < n_; ++i) { + operator()(i) -= b(i); + } + return *this; + } + + // scalar multiplication + Vector &operator*=(double x) { + for (int i = 0; i < n_; ++i) { + operator()(i) *= x; + } + return *this; + } + + // dot product between two vectors + double dot(const Vector &other) const { + double sum = 0; + for (int i = 0; i < n_; ++i) { + sum += operator()(i) * other(i); + } + return sum; + } + +private: + int n_; // vector dimension + std::vector data_; // the vectors entries +}; + +inline double dot(const Vector &v1, const Vector &v2) { return v1.dot(v2); } + +// Print the vector as a table +inline std::ostream &operator<<(std::ostream &os, const Vector &a) { + const int width = 10; + const int precision = 4; + + const auto originalPrecision = os.precision(); + os << std::setprecision(precision); + + for (int i = 0; i < a.dim(); ++i) { + os << std::setw(width) << a(i) << " "; + } + + os << "\n"; + + os << std::setprecision(originalPrecision); + return os; +} + +// A very simple class for m times n matrices +class Matrix { +public: + // constructors + Matrix() : Matrix(0, 0) {} + Matrix(int m, int n) : m_(m), n_(n), data_(m_ * n_, 0) {} + Matrix(std::pair dim) : Matrix(dim.first, dim.second) {} + Matrix(int n) : Matrix(n, n) {} + Matrix(const Matrix &other) = default; + Matrix(Matrix &&other) = default; + ~Matrix() = default; + + // assignment operators + Matrix &operator=(const Matrix &other) = default; + Matrix &operator=(Matrix &&other) = default; + + // element access + double &operator()(int i, int j) { return data_[i * n_ + j]; } + const double &operator()(int i, int j) const { return data_[i * n_ + j]; } + + // getter functions for the dimensions + std::pair dim() const { return std::pair(m_, n_); } + int dim1() const { return m_; } + int dim2() const { return n_; } + int numEntries() const { return data_.size(); } + + // comparison operators + bool operator==(const Matrix &b) { return (data_ == b.data_); } + bool operator!=(const Matrix &b) { return (data_ != b.data_); } + + // addition + Matrix &operator+=(const Matrix &b) { + for (int i = 0; i < m_; ++i) { + for (int j = 0; j < n_; ++j) { + operator()(i, j) += b(i, j); + } + } + return *this; + } + + // subtraction + Matrix &operator-=(const Matrix &b) { + for (int i = 0; i < m_; ++i) { + for (int j = 0; j < n_; ++j) { + operator()(i, j) -= b(i, j); + } + } + return *this; + } + + // scalar multiplication + Matrix &operator*=(double x) { + for (int i = 0; i < m_; ++i) { + for (int j = 0; j < n_; ++j) { + operator()(i, j) *= x; + } + } + return *this; + } + + // scalar division + Matrix &operator/=(double x) { + for (int i = 0; i < m_; ++i) { + for (int j = 0; j < n_; ++j) { + operator()(i, j) /= x; + } + } + return *this; + } + + // matrix product (only for square matrices of equal dimension) + Matrix &operator*=(const Matrix &b) { + if (dim1() != dim2()) { + std::cout << "Error in matrix multiplication: no square matrix\n"; + } else if (dim1() != b.dim1() || dim2() != b.dim2()) { + std::cout << "Error in matrix multiplication: dimensions do not match\n"; + } else { + Matrix a = *this; + Matrix &c = *this; + const int m = dim1(); + for (int i = 0; i < m; ++i) { + for (int j = 0; j < m; ++j) { + for (int k = 0; k < m; ++k) { + c(i, j) += a(i, k) * b(k, j); + } + } + } + } + + return *this; + } + +public: + int m_; // first dimension + int n_; // second dimension + std::vector data_; // the matrix' entries +}; + +// Print the matrix as a table +inline std::ostream &operator<<(std::ostream &os, const Matrix &a) { + const int width = 10; + const int precision = 4; + + const auto originalPrecision = os.precision(); + os << std::setprecision(precision); + + for (int i = 0; i < a.dim1(); ++i) { + for (int j = 0; j < a.dim2(); ++j) { + os << std::setw(width) << a(i, j) << " "; + } + if (i != a.dim1() - 1) + os << "\n"; + } + + os << std::setprecision(originalPrecision); + return os; +} + +// matrix product +inline Matrix operator*(const Matrix &a, const Matrix &b) { + if (a.dim2() == b.dim1()) { + int m = a.dim1(); + int n = a.dim2(); + int p = b.dim2(); + Matrix c(m, p); + for (int i = 0; i < m; ++i) { + for (int j = 0; j < p; ++j) { + for (int k = 0; k < n; ++k) { + c(i, j) += a(i, k) * b(k, j); + } + } + } + return c; + } else { + return Matrix(0, 0); + } +} + +inline bool equalWithinRange(const Matrix &a, const Matrix &b, + double eps = 1e-12) { + if (a.dim1() != b.dim1() || a.dim2() != b.dim2()) + return false; + + int m = a.dim1(); + int n = a.dim2(); + for (int i = 0; i < m; ++i) { + for (int j = 0; j < n; ++j) { + if (fabs(a(i, j) - b(i, j)) > eps) { + return false; + } + } + } + + return true; +} + +// A very simple class for "3D-Matrices" (tensors) with dimension l x m x n +class Matrix3D { +public: + // constructors + Matrix3D(int l, int m, int n) : l_(l), m_(m), n_(n), data_(l) { + for (int i = 0; i < l_; ++i) { + data_[i] = std::vector>(m_); + for (int j = 0; j < m_; ++j) { + data_[i][j] = std::vector(n_, 0); + } + } + } + Matrix3D(int n) : Matrix3D(n, n, n) {} + Matrix3D(const Matrix3D &other) = default; + Matrix3D(Matrix3D &&other) = default; + ~Matrix3D() = default; + + // assignment operators + Matrix3D &operator=(const Matrix3D &other) = default; + Matrix3D &operator=(Matrix3D &&other) = default; + + // element access + double &operator()(int i, int j, int k) { return data_[i][j][k]; } + const double &operator()(int i, int j, int k) const { return data_[i][j][k]; } + + // getter functions for the dimensions + int dim1() const { return l_; } + int dim2() const { return m_; } + int dim3() const { return n_; } + + // comparison operators + bool operator==(const Matrix3D &b) { return (data_ == b.data_); } + bool operator!=(const Matrix3D &b) { return (data_ != b.data_); } + + // addition + Matrix3D &operator+=(const Matrix3D &b) { + for (int i = 0; i < l_; ++i) { + for (int j = 0; j < m_; ++j) { + for (int k = 0; k < n_; ++k) { + operator()(i, j, k) += b(i, j, k); + } + } + } + return *this; + } + + // substraction + Matrix3D &operator-=(const Matrix3D &b) { + for (int i = 0; i < l_; ++i) { + for (int j = 0; j < m_; ++j) { + for (int k = 0; k < n_; ++k) { + operator()(i, j, k) -= b(i, j, k); + } + } + } + return *this; + } + + // scalar multiplication + Matrix3D &operator*=(double x) { + for (int i = 0; i < l_; ++i) { + for (int j = 0; j < m_; ++j) { + for (int k = 0; k < n_; ++k) { + operator()(i, j, k) *= x; + } + } + } + return *this; + } + + // scalar division + Matrix3D &operator/=(double x) { + for (int i = 0; i < l_; ++i) { + for (int j = 0; j < m_; ++j) { + for (int k = 0; k < n_; ++k) { + operator()(i, j, k) /= x; + } + } + } + return *this; + } + +private: + int l_; // first dimension + int m_; // second dimension + int n_; // third dimension + std::vector>> data_; // the tensors' entries +}; + +#endif // MATRIX_H diff --git a/lab02/fib/src/main.cpp b/lab02/fib/src/main.cpp new file mode 100644 index 0000000..e69de29