PASS - Matrix::Matrix();

PASS - virtual Matrix::~Matrix();

PASS - Matrix::Matrix(0, 0)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(0, 1)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(0, 2)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(0, 3)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(0, 4)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(0, 5)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(0, 6)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(0, 7)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(0, 8)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(0, 9)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(1, 0)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(1, 1)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(1, 2)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(1, 3)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(1, 4)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(1, 5)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(1, 6)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(1, 7)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(1, 8)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(1, 9)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(2, 0)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(2, 1)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(2, 2)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(2, 3)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(2, 4)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(2, 5)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(2, 6)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(2, 7)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(2, 8)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(2, 9)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(3, 0)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(3, 1)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(3, 2)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(3, 3)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(3, 4)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(3, 5)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(3, 6)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(3, 7)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(3, 8)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (length)

PASS - (implementation-defined) Matrix::row(std::size_t) const (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (length)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::column(std::size_t) (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (length)

PASS - (implementation-defined) Matrix::column(std::size_t) const (row range checking)

PASS - (implementation-defined) Matrix::column(std::size_t) const (column range checking)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - Matrix (indexing sanity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (no similarity)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same rows)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same columns)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (same size)

PASS - bool operator==(and operator!=)(const Matrix&, const Matrix&) (equality)

PASS - Matrix operator+(const Matrix&, const Matrix&)

PASS - Matrix operator+(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator+(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator-(const Matrix&, const Matrix&)

PASS - Matrix operator-(const Matrix&, const Matrix&) (size mismatch)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same rows)

PASS - Matrix operator-(const Matrix&, const Matrix&) (same columns)

PASS - Matrix operator*(const Matrix&, const float&)

PASS - Matrix operator*(const float&, const Matrix&)

PASS - Matrix operator/(const Matrix&, const float&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - Matrix operator*(const Matrix&, const Matrix&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - std::valarray operator*(const Matrix&, const std::valarray&)

PASS - const Matrix& operator=(const float&)

PASS - const Matrix& operator+=(const float&)

PASS - const Matrix& operator-=(const float&)

PASS - subscripted computed assignment

PASS - subscripted assignment

PASS - Matrix::Matrix(3, 9)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix::Matrix(const Matrix&)

PASS - Matrix& Matrix::operator=(const Matrix&)

PASS - std::size_t Matrix::rows() const

PASS - std::size_t Matrix::columns() const

PASS - std::pair Matrix::columns() const

PASS - void Matrix::resize(std::size_t, std::size_t)

PASS - Matrix Matrix::operator+() const

PASS - Matrix Matrix::operator-() const

PASS - Matrix& Matrix::operator*=(const float&)

PASS - Matrix& Matrix::operator/=(const float&)

PASS - Matrix& Matrix::operator+=(const Matrix&)

PASS - Matrix& Matrix::operator+=(const Matrix&) (different sizes)

PASS - Matrix& Matrix::operator-=(const Matrix&)

PASS - Matrix& Matrix::operator-=(const Matrix&) (different sizes)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripted assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (computed assignment)

PASS - (implementation-defined) Matrix::row(std::size_t) (column range checking)

PASS - (implementation-defined) Matrix::row(std::size_t) (length)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)

PASS - (implementation-defined) Matrix::row(std::size_t) (subscripting)