Definitions of Matrix and related classes and functions. More...
#include <climits>#include <iostream>#include <iomanip>#include <string>#include <sstream>#include <fstream>#include <iterator>#include <algorithm>#include <functional>#include <list>#include "scythestat/defs.h"#include "scythestat/algorithm.h"#include "scythestat/error.h"#include "scythestat/datablock.h"#include "scythestat/matrix_random_access_iterator.h"#include "scythestat/matrix_forward_iterator.h"#include "scythestat/matrix_bidirectional_iterator.h"#include "scythestat/lapack.h"
Include dependency graph for matrix.h:
This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Classes | |
| class | scythe::ListInitializer< T_elem, T_iter, O, S > |
| A helper class for list-wise initialization. More... | |
| class | scythe::Matrix_base< ORDER, STYLE > |
| Matrix superclass. More... | |
| class | scythe::Matrix< T_type, ORDER, STYLE > |
| An STL-compliant matrix container class. More... | |
Namespaces | |
| namespace | scythe |
The Scythe library namespace. | |
Defines | |
| #define | SCYTHE_BINARY_OPERATOR_DMM(OP) |
| #define | SCYTHE_BINARY_OPERATOR_GMS(OP) |
| #define | SCYTHE_BINARY_OPERATOR_DMS(OP) |
| #define | SCYTHE_BINARY_OPERATOR_GSM(OP) |
| #define | SCYTHE_BINARY_OPERATOR_DSM(OP) |
| #define | SCYTHE_BINARY_OPERATOR_DEFS(OP) |
| #define | SCYTHE_GENERAL_BINARY_OPERATOR(OP, FUNCTOR) |
| #define | SCYTHE_GENERAL_BINARY_BOOL_OPERATOR(OP, FUNCTOR) |
| #define | SCYTHE_BINARY_BOOL_OPERATOR_DMM(OP) |
| #define | SCYTHE_BINARY_BOOL_OPERATOR_GMS(OP) |
| #define | SCYTHE_BINARY_BOOL_OPERATOR_DMS(OP) |
| #define | SCYTHE_BINARY_BOOL_OPERATOR_GSM(OP) |
| #define | SCYTHE_BINARY_BOOL_OPERATOR_DSM(OP) |
| #define | SCYTHE_BINARY_BOOL_OPERATOR_DEFS(OP) |
Functions | |
| template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< T_type, ORDER, STYLE > | scythe::operator* (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| Multiply two matrices. | |
| template<matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE, typename T_type > | |
| Matrix< T_type, L_ORDER, Concrete > | scythe::operator* (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| Multiply two matrices. | |
| template<matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE, typename T_type > | |
| Matrix< T_type, ORDER, Concrete > | scythe::operator* (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE> | |
| Matrix< T_type, ORDER, STYLE > | scythe::operator* (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<matrix_order ORDER, matrix_style L_STYLE, typename T_type > | |
| Matrix< T_type, ORDER, Concrete > | scythe::operator* (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< T_type, ORDER, STYLE > | scythe::operator* (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<matrix_order ORDER, matrix_style R_STYLE, typename T_type > | |
| Matrix< T_type, ORDER, Concrete > | scythe::operator* (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< T_type, ORDER, STYLE > | scythe::kronecker (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| Kronecker multiply two matrices. | |
| template<matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE, typename T_type > | |
| Matrix< T_type, ORDER, Concrete > | scythe::kronecker (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE> | |
| Matrix< T_type, ORDER, STYLE > | scythe::kronecker (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<matrix_order ORDER, matrix_style L_STYLE, typename T_type > | |
| Matrix< T_type, ORDER, Concrete > | scythe::kronecker (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< T_type, ORDER, STYLE > | scythe::kronecker (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<matrix_order ORDER, matrix_style R_STYLE, typename T_type > | |
| Matrix< T_type, ORDER, Concrete > | scythe::kronecker (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< T_type, ORDER, STYLE > | scythe::operator+ (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| Add two matrices. | |
| template<matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE, typename T_type > | |
| Matrix< T_type, ORDER, Concrete > | scythe::operator+ (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE> | |
| Matrix< T_type, ORDER, STYLE > | scythe::operator+ (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<matrix_order ORDER, matrix_style L_STYLE, typename T_type > | |
| Matrix< T_type, ORDER, Concrete > | scythe::operator+ (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< T_type, ORDER, STYLE > | scythe::operator+ (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<matrix_order ORDER, matrix_style R_STYLE, typename T_type > | |
| Matrix< T_type, ORDER, Concrete > | scythe::operator+ (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< T_type, ORDER, STYLE > | scythe::operator- (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| Subtract two matrices. | |
| template<matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE, typename T_type > | |
| Matrix< T_type, ORDER, Concrete > | scythe::operator- (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE> | |
| Matrix< T_type, ORDER, STYLE > | scythe::operator- (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<matrix_order ORDER, matrix_style L_STYLE, typename T_type > | |
| Matrix< T_type, ORDER, Concrete > | scythe::operator- (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< T_type, ORDER, STYLE > | scythe::operator- (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<matrix_order ORDER, matrix_style R_STYLE, typename T_type > | |
| Matrix< T_type, ORDER, Concrete > | scythe::operator- (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< T_type, ORDER, STYLE > | scythe::operator% (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| Element multiply two matrices. | |
| template<matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE, typename T_type > | |
| Matrix< T_type, ORDER, Concrete > | scythe::operator% (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE> | |
| Matrix< T_type, ORDER, STYLE > | scythe::operator% (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<matrix_order ORDER, matrix_style L_STYLE, typename T_type > | |
| Matrix< T_type, ORDER, Concrete > | scythe::operator% (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< T_type, ORDER, STYLE > | scythe::operator% (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<matrix_order ORDER, matrix_style R_STYLE, typename T_type > | |
| Matrix< T_type, ORDER, Concrete > | scythe::operator% (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< T_type, ORDER, STYLE > | scythe::operator/ (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| Divide two matrices. | |
| template<matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE, typename T_type > | |
| Matrix< T_type, ORDER, Concrete > | scythe::operator/ (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE> | |
| Matrix< T_type, ORDER, STYLE > | scythe::operator/ (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<matrix_order ORDER, matrix_style L_STYLE, typename T_type > | |
| Matrix< T_type, ORDER, Concrete > | scythe::operator/ (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< T_type, ORDER, STYLE > | scythe::operator/ (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<matrix_order ORDER, matrix_style R_STYLE, typename T_type > | |
| Matrix< T_type, ORDER, Concrete > | scythe::operator/ (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< T_type, ORDER, STYLE > | scythe::operator^ (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| Exponentiate one Matrix by another. | |
| template<matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE, typename T_type > | |
| Matrix< T_type, ORDER, Concrete > | scythe::operator^ (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE> | |
| Matrix< T_type, ORDER, STYLE > | scythe::operator^ (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<matrix_order ORDER, matrix_style L_STYLE, typename T_type > | |
| Matrix< T_type, ORDER, Concrete > | scythe::operator^ (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< T_type, ORDER, STYLE > | scythe::operator^ (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<matrix_order ORDER, matrix_style R_STYLE, typename T_type > | |
| Matrix< T_type, ORDER, Concrete > | scythe::operator^ (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs) |
| template<typename T_type , matrix_order R_ORDER, matrix_style R_STYLE, matrix_order ORDER, matrix_style STYLE> | |
| Matrix< T_type, R_ORDER, R_STYLE > | scythe::operator- (const Matrix< T_type, ORDER, STYLE > &M) |
| Negate a Matrix. | |
| template<matrix_order ORDER, matrix_style P_STYLE, typename T_type > | |
| Matrix< T_type, ORDER, Concrete > | scythe::operator- (const Matrix< T_type, ORDER, P_STYLE > &M) |
| template<matrix_order R_ORDER, matrix_style R_STYLE, typename T_type , matrix_order ORDER, matrix_style STYLE> | |
| Matrix< bool, R_ORDER, R_STYLE > | scythe::operator! (const Matrix< T_type, ORDER, STYLE > &M) |
| Logically NOT a Matrix. | |
| template<typename T_type , matrix_order ORDER, matrix_style P_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator! (const Matrix< T_type, ORDER, P_STYLE > &M) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator== (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| Test Matrix equality. | |
| template<typename T_type , matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator== (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator== (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style L_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator== (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator== (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator== (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator!= (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| Test Matrix equality. | |
| template<typename T_type , matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator!= (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator!= (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style L_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator!= (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator!= (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator!= (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator< (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| Test Matrix inequality. | |
| template<typename T_type , matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator< (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator< (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style L_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator< (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator< (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator< (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator<= (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| Test Matrix inequality. | |
| template<typename T_type , matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator<= (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator<= (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style L_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator<= (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator<= (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator<= (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator> (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| Test Matrix inequality. | |
| template<typename T_type , matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator> (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator> (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style L_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator> (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator> (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator> (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator>= (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| Test Matrix inequality. | |
| template<typename T_type , matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator>= (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator>= (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style L_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator>= (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator>= (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator>= (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator& (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| Logically AND two matrices. | |
| template<typename T_type , matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator& (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator& (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style L_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator& (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator& (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator& (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator| (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| Logically OR two matrices. | |
| template<typename T_type , matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator| (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator| (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style L_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator| (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs) |
| template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order R_ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, STYLE > | scythe::operator| (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs) |
| template<typename T_type , matrix_order ORDER, matrix_style R_STYLE> | |
| Matrix< bool, ORDER, Concrete > | scythe::operator| (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs) |
| template<typename T , matrix_order O, matrix_style S> | |
| std::istream & | scythe::operator>> (std::istream &is, Matrix< T, O, S > &M) |
| Populate a Matrix from a stream. | |
| template<typename T , matrix_order O, matrix_style S> | |
| std::ostream & | scythe::operator<< (std::ostream &os, const Matrix< T, O, S > &M) |
| Write a Matrix to a stream. | |
| template<> | |
| Matrix | scythe::operator*< double, Col, Concrete, Col, Concrete > (const Matrix<> &lhs, const Matrix<> &rhs) |
Detailed Description
Definitions of Matrix and related classes and functions.
This file contains the definitions of the Matrix, Matrix_base, and associated classes. It also contains a number of external functions that operate on Matrix objects, such as mathematical operators.
Many of the arithmetic and logical operators in this file are implemented in terms of overloaded template definitions to provide both generic and default versions of each operation. Generic templates allow (and force) the user to fully specify the template type of the returned matrix object (row or column order, concrete or view) while default templates automatically return concrete matrices with the ordering of the first or only Matrix argument to the function. Furthermore, we overload binary functions to provide scalar by Matrix operations, in addition to basic Matrix by Matrix arithmetic and logic. Therefore, definitions for multiple versions appear in the functions list below. We adopt the convention of providing explicit documentation for only the most generic Matrix by Matrix version of each of these operators and describe the behavior of the various overloaded versions in these documents.
