Matrix.h

#pragma once
 
#include <array>
#include <cstdint>
#include <initializer_list>
#include <ostream>
#include <string>
 
#include <iolink/IOLinkAPI.h>
#include <iolink/Vector.h>
 
namespace iolink
{
 
template <typename ValueType, size_t N>
class Matrix
{
public:
  static Matrix identity();
 
  static Matrix uniform(ValueType value);
 
  Matrix();
 
  explicit Matrix(const ValueType* values);
 
  Matrix(const ValueType* values, bool isRowMajor);
 
  explicit Matrix(std::initializer_list<ValueType> init);
 
  bool operator==(const Matrix& other) const;
  bool operator!=(const Matrix& other) const;
 
  ValueType at(size_t row, size_t column) const;
 
  ValueType operator()(size_t row, size_t column) const;
 
  void setAt(size_t row, size_t column, ValueType value);
 
  void transposeInPlace();
 
  Matrix transpose() const;
 
  Matrix inverse() const;
 
  ValueType* data();
 
  const ValueType* data() const;
 
  std::string toString() const;
 
  // ==================== //
  // Arithmetic operators //
  // ==================== //
 
  Matrix operator-() const;
 
  Matrix& operator+=(const Matrix& m);
  Matrix& operator-=(const Matrix& m);
 
  inline Matrix operator+(const Matrix& m) const { return Matrix(*this) += m; }
  inline Matrix operator-(const Matrix& m) const { return Matrix(*this) -= m; }
 
  Matrix& operator*=(ValueType value);
  Matrix& operator/=(ValueType value);
 
  inline Matrix operator*(ValueType v) const { return Matrix(*this) *= v; }
  inline Matrix operator/(ValueType v) const { return Matrix(*this) /= v; }
 
  Vector<ValueType, N> operator*(const Vector<ValueType, N>& v) const;
  Matrix operator*(const Matrix& m) const;
 
private:
  std::array<ValueType, N * N> m_data;
};
 
template <typename T, size_t N>
inline std::ostream&
operator<<(std::ostream& os, const Matrix<T, N>& m)
{
  os << m.toString();
  return os;
}
 
//=======================//
// Template declarations //
//=======================//
 
extern template class IOLINK_API_IMPORT Matrix<float, 3>;
extern template class IOLINK_API_IMPORT Matrix<double, 3>;
 
extern template class IOLINK_API_IMPORT Matrix<float, 4>;
extern template class IOLINK_API_IMPORT Matrix<double, 4>;
 
//======================//
// Aliases declarations //
//======================//
 
using Matrix3f = Matrix<float, 3>;  
using Matrix3d = Matrix<double, 3>; 
 
using Matrix4f = Matrix<float, 4>;  
using Matrix4d = Matrix<double, 4>; 
 
} // end namespace iolink