d9/d1c/Matrix_8hpp_source.html

 #pragma once


 #include "Arduino/ArduinoConfig.hpp"


 #include <algorithm>  // std::fill, std::transform

 #include <cassert>    // assert

 #include <cmath>      // std::sqrt

 #include <functional> // std::plus, std::minus

 #include <numeric>    // std::inner_product

 #include <utility>    // std::swap

 #include <vector>     // std::vector


 #ifndef NO_IOSTREAM_SUPPORT

 #include <iosfwd> // std::ostream

 #endif


 #ifndef NO_RANDOM_SUPPORT

 #include <random> // std::uniform_real_distribution

 #endif


 using std::size_t;


 #include "util/MatrixStorage.hpp"


 #ifndef COL_MAJ_ORDER

 #define COL_MAJ_ORDER 1

 #endif


 #ifndef NO_ARDUINO_PRINT_SUPPORT

 class Matrix : public Printable {

 #else

 class Matrix {

 #endif


     using storage_t = util::storage_t<double>;


   protected:

     explicit Matrix(storage_t &&storage, size_t rows, size_t cols);

     explicit Matrix(const storage_t &storage, size_t rows, size_t cols);


   public:


     Matrix() = default;


     Matrix(size_t rows, size_t cols);


     Matrix(std::initializer_list<std::initializer_list<double>> init);

     Matrix &

     operator=(std::initializer_list<std::initializer_list<double>> init);


     Matrix(const Matrix &) = default;

     Matrix(Matrix &&);


     Matrix &operator=(const Matrix &) = default;

     Matrix &operator=(Matrix &&);


   public:


     size_t rows() const { return rows_; }

     size_t cols() const { return cols_; }

     size_t num_elems() const { return storage.size(); }


     void reshape(size_t newrows, size_t newcols);

     Matrix reshaped(size_t newrows, size_t newcols) const;


   public:


     double &operator()(size_t row, size_t col);

     const double &operator()(size_t row, size_t col) const;


     double &operator()(size_t index) { return storage[index]; }

     const double &operator()(size_t index) const { return storage[index]; }


   public:


     void clear_and_deallocate();


   public:


     void fill(double value);


     void fill_identity();


 #ifndef NO_RANDOM_SUPPORT

     void fill_random(double min = 0, double max = 1,

                      std::default_random_engine::result_type seed =

                          std::default_random_engine::default_seed);

 #endif


   public:


     static Matrix ones(size_t rows, size_t cols);


     static Matrix zeros(size_t rows, size_t cols);


     static Matrix constant(size_t rows, size_t cols, double value);


     static Matrix identity(size_t rows, size_t cols);


     static Matrix identity(size_t rows);


 #ifndef NO_RANDOM_SUPPORT

     static Matrix random(size_t rows, size_t cols, double min = 0,

                          double max = 1,

                          std::default_random_engine::result_type seed =

                              std::default_random_engine::default_seed);

 #endif


   public:


     void swap_rows(size_t a, size_t b);

     void swap_columns(size_t a, size_t b);


   public:


     bool operator==(const Matrix &other) const;

     bool operator!=(const Matrix &other) const { return !(*this == other); }


   public:


     double normFro() const &;

     double normFro() &&;


   public:


     storage_t::iterator begin() { return storage.begin(); }

     storage_t::const_iterator begin() const { return storage.begin(); }

     storage_t::const_iterator cbegin() const { return storage.begin(); }


     storage_t::iterator end() { return storage.end(); }

     storage_t::const_iterator end() const { return storage.end(); }

     storage_t::const_iterator cend() const { return storage.end(); }


   public:


 #ifndef NO_IOSTREAM_SUPPORT

     void print(std::ostream &os, uint8_t precision = 0,

                uint8_t width = 0) const;

 #endif


 #ifndef NO_ARDUINO_PRINT_SUPPORT

     void print(Print &print, uint8_t precision = 0, uint8_t width = 0) const;


     size_t printTo(Print &print) const override {

         this->print(print);

         return 0;

     }

 #endif


   protected:

     size_t rows_ = 0, cols_ = 0;

     storage_t storage;


     friend class Vector;

     friend class RowVector;

 };


 // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: //


 class Vector : public Matrix {

   public:


     Vector() = default;


     Vector(size_t size) : Matrix(size, 1) {}


     Vector(std::initializer_list<double> init) { *this = init; }


     Vector &operator=(std::initializer_list<double> init);


     explicit Vector(const Matrix &matrix);

     explicit Vector(Matrix &&matrix);


   public:


     void resize(size_t size) { storage.resize(size); }


     size_t size() const { return num_elems(); }


     void reshape(size_t, size_t) = delete;

     Matrix reshaped(size_t, size_t) = delete;


   public:


     static Vector ones(size_t size);

     static Vector zeros(size_t size);

     static Vector constant(size_t size, double value);


 #ifndef NO_RANDOM_SUPPORT

     static Vector random(size_t size, double min = 0, double max = 1,

                          std::default_random_engine::result_type seed =

                              std::default_random_engine::default_seed);

 #endif


   public:


     static double dot_unchecked(const Matrix &a, const Matrix &b);

     static double dot_unchecked(Matrix &&a, const Matrix &b);

     static double dot_unchecked(const Matrix &a, Matrix &&b);

     static double dot_unchecked(Matrix &&a, Matrix &&b);


     static double dot(const Vector &a, const Vector &b);

     static double dot(Vector &&a, const Vector &b);

     static double dot(const Vector &a, Vector &&b);

     static double dot(Vector &&a, Vector &&b);


     double dot(const Vector &b) const & { return dot(*this, b); }

     double dot(const Vector &b) && { return dot(std::move(*this), b); }

     double dot(Vector &&b) const & { return dot(*this, std::move(b)); }

     double dot(Vector &&b) && { return dot(std::move(*this), std::move(b)); }


   public:


     static void cross_inplace_unchecked(Matrix &a, const Matrix &b);

     static void cross_inplace_unchecked_neg(Matrix &a, const Matrix &b);


     static void cross_inplace(Vector &a, const Vector &b);

     static void cross_inplace(Vector &a, Vector &&b);

     static void cross_inplace_neg(Vector &a, const Vector &b);

     static void cross_inplace_neg(Vector &a, Vector &&b);


     static Vector cross(const Vector &a, const Vector &b);

     static Vector &&cross(Vector &&a, const Vector &b);

     static Vector &&cross(const Vector &a, Vector &&b);

     static Vector &&cross(Vector &&a, Vector &&b);


     Vector cross(const Vector &b) const & { return cross(*this, b); }

     Vector &&cross(const Vector &b) && { return cross(std::move(*this), b); }

     Vector &&cross(Vector &&b) const & { return cross(*this, std::move(b)); }

     Vector &&cross(Vector &&b) && {

         return cross(std::move(*this), std::move(b));

     }


   public:


     double norm2() const &;

     double norm2() &&;


 };


 class RowVector : public Matrix {

   public:


     RowVector() = default;


     RowVector(size_t size) : Matrix(1, size) {}


     RowVector(std::initializer_list<double> init) { *this = init; }


     RowVector &operator=(std::initializer_list<double> init);


     explicit RowVector(const Matrix &matrix);

     explicit RowVector(Matrix &&matrix);


   public:


     void resize(size_t size) { storage.resize(size); }


     size_t size() const { return num_elems(); }


     void reshape(size_t, size_t) = delete;

     Matrix reshaped(size_t, size_t) = delete;


   public:


     static RowVector ones(size_t size);

     static RowVector zeros(size_t size);

     static RowVector constant(size_t size, double value);


 #ifndef NO_RANDOM_SUPPORT

     static RowVector random(size_t size, double min = 0, double max = 1,

                             std::default_random_engine::result_type seed =

                                 std::default_random_engine::default_seed);

 #endif


   public:


     static double dot(const RowVector &a, const RowVector &b);

     static double dot(RowVector &&a, const RowVector &b);

     static double dot(const RowVector &a, RowVector &&b);

     static double dot(RowVector &&a, RowVector &&b);


     double dot(const RowVector &b) const & { return dot(*this, b); }

     double dot(const RowVector &b) && { return dot(std::move(*this), b); }

     double dot(RowVector &&b) const & { return dot(*this, std::move(b)); }

     double dot(RowVector &&b) && { return dot(std::move(*this), std::move(b)); }


   public:


     static void cross_inplace(RowVector &a, const RowVector &b);

     static void cross_inplace(RowVector &a, RowVector &&b);

     static void cross_inplace_neg(RowVector &a, const RowVector &b);

     static void cross_inplace_neg(RowVector &a, RowVector &&b);


     static RowVector cross(const RowVector &a, const RowVector &b);

     static RowVector &&cross(RowVector &&a, const RowVector &b);

     static RowVector &&cross(const RowVector &a, RowVector &&b);

     static RowVector &&cross(RowVector &&a, RowVector &&b);


     RowVector cross(const RowVector &b) const &;

     RowVector &&cross(const RowVector &b) &&;

     RowVector &&cross(RowVector &&b) const &;

     RowVector &&cross(RowVector &&b) &&;


   public:


     double norm2() const &;

     double norm2() &&;


 };


 class SquareMatrix : public Matrix {

   public:


     SquareMatrix() = default;


     SquareMatrix(size_t size) : Matrix(size, size) {}


     SquareMatrix(std::initializer_list<std::initializer_list<double>> init);


     explicit SquareMatrix(Matrix &&matrix);

     explicit SquareMatrix(const Matrix &matrix);


     SquareMatrix &

     operator=(std::initializer_list<std::initializer_list<double>> init);


   public:


     void reshape(size_t, size_t) = delete;

     Matrix reshaped(size_t, size_t) = delete;


   public:


     static void transpose_inplace(Matrix &A);

     void transpose_inplace() { transpose_inplace(*this); }


   public:


     static SquareMatrix ones(size_t rows);

     static SquareMatrix zeros(size_t rows);

     static SquareMatrix constant(size_t rows, double value);


     static SquareMatrix identity(size_t rows);


 #ifndef NO_RANDOM_SUPPORT

     static SquareMatrix random(size_t rows, double min = 0, double max = 1,

                                std::default_random_engine::result_type seed =

                                    std::default_random_engine::default_seed);

 #endif


 };


 #ifndef NO_IOSTREAM_SUPPORT

 std::ostream &operator<<(std::ostream &os, const Matrix &M);

 #endif


 #ifndef NO_ARDUINO_PRINT_SUPPORT

 Print &operator<<(Print &p, const Matrix &M);

 #endif


 // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: //


 Matrix operator*(const Matrix &A, const Matrix &B);

 Matrix operator*(Matrix &&A, const Matrix &B);

 Matrix operator*(const Matrix &A, Matrix &&B);

 Matrix operator*(Matrix &&A, Matrix &&B);


 SquareMatrix operator*(const SquareMatrix &A, const SquareMatrix &B);

 SquareMatrix operator*(SquareMatrix &&A, const SquareMatrix &B);

 SquareMatrix operator*(const SquareMatrix &A, SquareMatrix &&B);

 SquareMatrix operator*(SquareMatrix &&A, SquareMatrix &&B);


 Vector operator*(const Matrix &A, const Vector &b);

 Vector operator*(Matrix &&A, const Vector &b);

 Vector operator*(const Matrix &A, Vector &&b);

 Vector operator*(Matrix &&A, Vector &&b);


 RowVector operator*(const RowVector &a, const Matrix &B);

 RowVector operator*(RowVector &&a, const Matrix &B);

 RowVector operator*(const RowVector &a, Matrix &&B);

 RowVector operator*(RowVector &&a, Matrix &&B);


 double operator*(const RowVector &a, const Vector &b);

 double operator*(RowVector &&a, const Vector &b);

 double operator*(const RowVector &a, Vector &&b);

 double operator*(RowVector &&a, Vector &&b);


 // -------------------------------------------------------------------------- //


 Matrix operator+(const Matrix &A, const Matrix &B);


 void operator+=(Matrix &A, const Matrix &B);

 Matrix &&operator+(Matrix &&A, const Matrix &B);

 Matrix &&operator+(const Matrix &A, Matrix &&B);

 Matrix &&operator+(Matrix &&A, Matrix &&B);

 Vector &&operator+(Vector &&a, const Vector &b);

 Vector &&operator+(const Vector &a, Vector &&b);

 Vector &&operator+(Vector &&a, Vector &&b);

 RowVector &&operator+(RowVector &&a, const RowVector &b);

 RowVector &&operator+(const RowVector &a, RowVector &&b);

 RowVector &&operator+(RowVector &&a, RowVector &&b);

 SquareMatrix &&operator+(SquareMatrix &&a, const SquareMatrix &b);

 SquareMatrix &&operator+(const SquareMatrix &a, SquareMatrix &&b);

 SquareMatrix &&operator+(SquareMatrix &&a, SquareMatrix &&b);

 Vector operator+(const Vector &a, const Vector &b);

 RowVector operator+(const RowVector &a, const RowVector &b);

 SquareMatrix operator+(const SquareMatrix &a, const SquareMatrix &b);


 // -------------------------------------------------------------------------- //


 Matrix operator-(const Matrix &A, const Matrix &B);

 void operator-=(Matrix &A, const Matrix &B);

 Matrix &&operator-(Matrix &&A, const Matrix &B);

 Matrix &&operator-(const Matrix &A, Matrix &&B);

 Matrix &&operator-(Matrix &&A, Matrix &&B);

 Vector &&operator-(Vector &&a, const Vector &b);

 Vector &&operator-(const Vector &a, Vector &&b);

 Vector &&operator-(Vector &&a, Vector &&b);

 RowVector &&operator-(RowVector &&a, const RowVector &b);

 RowVector &&operator-(const RowVector &a, RowVector &&b);

 RowVector &&operator-(RowVector &&a, RowVector &&b);

 SquareMatrix &&operator-(SquareMatrix &&a, const SquareMatrix &b);

 SquareMatrix &&operator-(const SquareMatrix &a, SquareMatrix &&b);

 SquareMatrix &&operator-(SquareMatrix &&a, SquareMatrix &&b);

 Vector operator-(const Vector &a, const Vector &b);

 RowVector operator-(const RowVector &a, const RowVector &b);

 SquareMatrix operator-(const SquareMatrix &a, const SquareMatrix &b);


 // -------------------------------------------------------------------------- //


 Matrix operator-(const Matrix &A);

 Matrix &&operator-(Matrix &&A);

 Vector &&operator-(Vector &&a);

 RowVector &&operator-(RowVector &&a);

 SquareMatrix &&operator-(SquareMatrix &&a);

 Vector operator-(const Vector &a);

 RowVector operator-(const RowVector &a);

 SquareMatrix operator-(const SquareMatrix &a);


 // -------------------------------------------------------------------------- //


 Matrix operator*(const Matrix &A, double s);

 void operator*=(Matrix &A, double s);

 Matrix &&operator*(Matrix &&A, double s);

 Vector operator*(const Vector &a, double s);

 RowVector operator*(const RowVector &a, double s);

 SquareMatrix operator*(const SquareMatrix &a, double s);

 Vector &&operator*(Vector &&a, double s);

 RowVector &&operator*(RowVector &&a, double s);

 SquareMatrix &&operator*(SquareMatrix &&a, double s);


 Matrix operator*(double s, const Matrix &A);

 Matrix &&operator*(double s, Matrix &&A);

 Vector operator*(double s, const Vector &a);

 RowVector operator*(double s, const RowVector &a);

 SquareMatrix operator*(double s, const SquareMatrix &a);

 Vector &&operator*(double s, Vector &&a);

 RowVector &&operator*(double s, RowVector &&a);

 SquareMatrix &&operator*(double s, SquareMatrix &&a);


 // -------------------------------------------------------------------------- //


 Matrix operator/(const Matrix &A, double s);

 void operator/=(Matrix &A, double s);

 Matrix &&operator/(Matrix &&A, double s);

 Vector operator/(const Vector &a, double s);

 RowVector operator/(const RowVector &a, double s);

 SquareMatrix operator/(const SquareMatrix &a, double s);

 Vector &&operator/(Vector &&a, double s);

 RowVector &&operator/(RowVector &&a, double s);

 SquareMatrix &&operator/(SquareMatrix &&a, double s);


 // -------------------------------------------------------------------------- //


 Matrix explicit_transpose(const Matrix &in);


 Matrix transpose(const Matrix &in);

 Matrix &&transpose(Matrix &&in);


 SquareMatrix transpose(const SquareMatrix &in);

 SquareMatrix &&transpose(SquareMatrix &&in);


 RowVector transpose(const Vector &in);

 RowVector transpose(Vector &&in);

 Vector transpose(const RowVector &in);

 Vector transpose(RowVector &&in);


ArduinoConfig.hpp
Preprocessor logic for configuring the library to make it compatible with the Arduino environment.

MatrixStorage.hpp

Matrix
General matrix class.
Definition: Matrix.hpp:34

Matrix::begin
storage_t::const_iterator begin() const
Get the iterator to the first element of the matrix.
Definition: Matrix.hpp:215

Matrix::constant
static Matrix constant(size_t rows, size_t cols, double value)
Create a matrix filled with a constant value.
Definition: Matrix.cpp:157

Matrix::identity
static Matrix identity(size_t rows, size_t cols)
Create an identity matrix.
Definition: Matrix.cpp:163

Matrix::printTo
size_t printTo(Print &print) const override
Implements the Arduino Printable interface.
Definition: Matrix.hpp:259

Matrix::random
static Matrix random(size_t rows, size_t cols, double min=0, double max=1, std::default_random_engine::result_type seed=std::default_random_engine::default_seed)
Create a matrix with uniformly distributed random values.
Definition: Matrix.cpp:172

Matrix::end
storage_t::iterator end()
Get the iterator to the element past the end of the matrix.
Definition: Matrix.hpp:220

Matrix::operator=
Matrix & operator=(const Matrix &)=default
Default copy assignment.

Matrix::operator<<
std::ostream & operator<<(std::ostream &os, const Matrix &M)
Print a matrix.
Definition: Matrix.cpp:255

Matrix::zeros
static Matrix zeros(size_t rows, size_t cols)
Create a matrix filled with zeros.
Definition: Matrix.cpp:152

Matrix::operator()
const double & operator()(size_t index) const
Get the element at the given position in the linearized matrix.
Definition: Matrix.hpp:109

Matrix::fill_random
void fill_random(double min=0, double max=1, std::default_random_engine::result_type seed=std::default_random_engine::default_seed)
Fill the matrix with uniformly distributed random values.
Definition: Matrix.cpp:136

Matrix::RowVector
friend class RowVector
Definition: Matrix.hpp:272

Matrix::storage
storage_t storage
Definition: Matrix.hpp:269

Matrix::cend
storage_t::const_iterator cend() const
Get the iterator to the element past the end of the matrix.
Definition: Matrix.hpp:224

Matrix::rows_
size_t rows_
Definition: Matrix.hpp:268

Matrix::swap_columns
void swap_columns(size_t a, size_t b)
Swap two columns of the matrix.
Definition: Matrix.cpp:184

Matrix::reshaped
Matrix reshaped(size_t newrows, size_t newcols) const
Create a reshaped copy of the matrix.
Definition: Matrix.cpp:84

Matrix::operator==
bool operator==(const Matrix &other) const
Check for equality of two matrices.
Definition: Matrix.cpp:198

Matrix::operator()
double & operator()(size_t row, size_t col)
Get the element at the given position in the matrix.
Definition: Matrix.cpp:94

Matrix::num_elems
size_t num_elems() const
Get the number of elements in the matrix:
Definition: Matrix.hpp:85

Matrix::ones
static Matrix ones(size_t rows, size_t cols)
Create a matrix filled with ones.
Definition: Matrix.cpp:148

Matrix::swap_rows
void swap_rows(size_t a, size_t b)
Swap two rows of the matrix.
Definition: Matrix.cpp:189

Matrix::Vector
friend class Vector
Definition: Matrix.hpp:271

Matrix::Matrix
Matrix()=default
Default constructor.

Matrix::rows
size_t rows() const
Get the number of rows of the matrix.
Definition: Matrix.hpp:81

Matrix::storage_t
util::storage_t< double > storage_t
Container to store the elements of the matrix internally.
Definition: Matrix.hpp:40

Matrix::cbegin
storage_t::const_iterator cbegin() const
Get the iterator to the first element of the matrix.
Definition: Matrix.hpp:217

Matrix::clear_and_deallocate
void clear_and_deallocate()
Set the number of rows and columns to zero, and deallocate the storage.
Definition: Matrix.cpp:114

Matrix::reshape
void reshape(size_t newrows, size_t newcols)
Reshape the matrix.
Definition: Matrix.cpp:78

Matrix::operator()
double & operator()(size_t index)
Get the element at the given position in the linearized matrix.
Definition: Matrix.hpp:107

Matrix::operator=
Matrix & operator=(std::initializer_list< std::initializer_list< double >> init)
Assign the given values to the matrix.
Definition: Matrix.cpp:45

Matrix::Matrix
Matrix(const Matrix &)=default
Default copy constructor.

Matrix::fill_identity
void fill_identity()
Fill the matrix as an identity matrix (all zeros except the diagonal which is one).
Definition: Matrix.cpp:129

Matrix::normFro
double normFro() const &
Compute the Frobenius norm of the matrix.
Definition: Matrix.cpp:219

Matrix::cols
size_t cols() const
Get the number of columns of the matrix.
Definition: Matrix.hpp:83

Matrix::cols_
size_t cols_
Definition: Matrix.hpp:268

Matrix::begin
storage_t::iterator begin()
Get the iterator to the first element of the matrix.
Definition: Matrix.hpp:213

Matrix::operator!=
bool operator!=(const Matrix &other) const
Check for inequality of two matrices.
Definition: Matrix.hpp:193

Matrix::fill
void fill(double value)
Fill the matrix with a constant value.
Definition: Matrix.cpp:125

Matrix::end
storage_t::const_iterator end() const
Get the iterator to the element past the end of the matrix.
Definition: Matrix.hpp:222

Matrix::print
void print(std::ostream &os, uint8_t precision=0, uint8_t width=0) const
Print a matrix.
Definition: Matrix.cpp:242

RowVector
A row vector (1×n matrix).
Definition: Matrix.hpp:437

RowVector::size
size_t size() const
Get the number of elements in the vector.
Definition: Matrix.hpp:469

RowVector::reshaped
Matrix reshaped(size_t, size_t)=delete
Reshaping a vector to a matrix requires an explicit cast.

RowVector::RowVector
RowVector(std::initializer_list< double > init)
Create a row vector from the given list of values.
Definition: Matrix.hpp:449

RowVector::resize
void resize(size_t size)
Resize the vector.
Definition: Matrix.hpp:466

RowVector::dot
double dot(RowVector &&b) const &
Compute the dot product of this vector with another vector.
Definition: Matrix.hpp:516

RowVector::RowVector
RowVector(size_t size)
Create a row vector of the given size.
Definition: Matrix.hpp:446

RowVector::dot
double dot(const RowVector &b) &&
Compute the dot product of this vector with another vector.
Definition: Matrix.hpp:514

RowVector::RowVector
RowVector()=default
Default constructor.

RowVector::reshape
void reshape(size_t, size_t)=delete
Reshaping a vector to a matrix requires an explicit cast.

RowVector::dot
double dot(RowVector &&b) &&
Compute the dot product of this vector with another vector.
Definition: Matrix.hpp:518

RowVector::dot
double dot(const RowVector &b) const &
Compute the dot product of this vector with another vector.
Definition: Matrix.hpp:512

SquareMatrix
Square matrix class.
Definition: Matrix.hpp:572

SquareMatrix::SquareMatrix
SquareMatrix(size_t size)
Create a square matrix of zeros.
Definition: Matrix.hpp:581

SquareMatrix::reshaped
Matrix reshaped(size_t, size_t)=delete
Reshaping a square matrix to a general matrix requires an explicit cast.

SquareMatrix::SquareMatrix
SquareMatrix()=default
Default constructor.

SquareMatrix::transpose_inplace
void transpose_inplace()
Transpose the matrix in-place.
Definition: Matrix.hpp:615

SquareMatrix::reshape
void reshape(size_t, size_t)=delete
Reshaping a square matrix to a general matrix requires an explicit cast.

Vector
A column vector (n×1 matrix).
Definition: Matrix.hpp:278

Vector::dot
double dot(const Vector &b) &&
Compute the dot product of this vector with another vector.
Definition: Matrix.hpp:368

Vector::size
size_t size() const
Get the number of elements in the vector.
Definition: Matrix.hpp:310

Vector::reshaped
Matrix reshaped(size_t, size_t)=delete
Reshaping a vector to a matrix requires an explicit cast.

Vector::dot
double dot(const Vector &b) const &
Compute the dot product of this vector with another vector.
Definition: Matrix.hpp:366

Vector::cross
Vector cross(const Vector &b) const &
Compute the cross product of this 3-vector with another 3-vector.
Definition: Matrix.hpp:412

Vector::dot
double dot(Vector &&b) &&
Compute the dot product of this vector with another vector.
Definition: Matrix.hpp:372

Vector::cross
Vector && cross(const Vector &b) &&
Compute the cross product of this 3-vector with another 3-vector,.
Definition: Matrix.hpp:414

Vector::cross
Vector && cross(Vector &&b) &&
Compute the cross product of this 3-vector with another 3-vector,.
Definition: Matrix.hpp:418

Vector::resize
void resize(size_t size)
Resize the vector.
Definition: Matrix.hpp:307

Vector::cross
Vector && cross(Vector &&b) const &
Compute the cross product of this 3-vector with another 3-vector,.
Definition: Matrix.hpp:416

Vector::Vector
Vector(size_t size)
Create a column vector of the given size.
Definition: Matrix.hpp:287

Vector::Vector
Vector()=default
Default constructor.

Vector::dot
double dot(Vector &&b) const &
Compute the dot product of this vector with another vector.
Definition: Matrix.hpp:370

Vector::reshape
void reshape(size_t, size_t)=delete
Reshaping a vector to a matrix requires an explicit cast.

Vector::Vector
Vector(std::initializer_list< double > init)
Create a column vector from the given list of values.
Definition: Matrix.hpp:290

operator+
Matrix operator+(const Matrix &A, const Matrix &B)
Matrix addition.
Definition: Matrix.cpp:720

operator+=
void operator+=(Matrix &A, const Matrix &B)
Definition: Matrix.cpp:730

operator*
Matrix operator*(const Matrix &A, const Matrix &B)
Matrix multiplication.
Definition: Matrix.cpp:622

operator-=
void operator-=(Matrix &A, const Matrix &B)
Definition: Matrix.cpp:820

operator-
Matrix operator-(const Matrix &A, const Matrix &B)
Matrix subtraction.
Definition: Matrix.cpp:810

transpose
Matrix transpose(const Matrix &in)
Matrix transpose for rectangular or square matrices and row or column vectors.
Definition: Matrix.cpp:1064

explicit_transpose
Matrix explicit_transpose(const Matrix &in)
Matrix transpose for general matrices.
Definition: Matrix.cpp:1050

operator/=
void operator/=(Matrix &A, double s)
Definition: Matrix.cpp:1011

operator/
Matrix operator/(const Matrix &A, double s)
Scalar division.
Definition: Matrix.cpp:1003

operator*=
void operator*=(Matrix &A, double s)
Definition: Matrix.cpp:953

util::storage_t
std::vector< T > storage_t
Container to store the elements of a matrix internally.
Definition: MatrixStorage.hpp:19