matrix.hpp File Reference

#include "config.hpp"
#include <cstddef>
#include <iostream>
#include <vector>
#include <utility>
#include "frwrddecl.hpp"
#include "type_opers.hpp"
#include "type_traits.hpp"
#include "type_pair_traits.hpp"
#include "exception.hpp"
#include "refcntr.hpp"
#include "factory.hpp"
#include "cmp.hpp"
#include "io.hpp"
#include "vector.hpp"
#include "std_import.hpp"
#include "matrix.cpp"

Go to the source code of this file.

Namespaces
namespace	Arageli
namespace	Arageli::_Internal
namespace	std
Classes
struct	Arageli::nonsquare_t
	Type for helper object fromsize. More...
struct	Arageli::colwise_t
	Type for helper object for columnwise filling of the matrix. More...
struct	Arageli::diag_t
	Type for helper object diag. More...
struct	Arageli::eye_t
	Type for helper object eye. More...
struct	Arageli::frommat_t
struct	Arageli::_Internal::Rep_matrix< T >
class	Arageli::matrix< T, REFCNT >
	Template class matrix. More...
struct	Arageli::matrix< T, REFCNT >::other_element_type< T1 >
	Defines vector type with other element type and the same reference counter. More...
struct	Arageli::matrix< T, REFCNT >::other_element_type_refcnt< T1, REFCNT1 >
	Defines vector type with other element type ane reference counter. More...
struct	Arageli::factory< matrix< T, REFCNT > >
	Specialization of the template 'factory' for the Arageli::matrix template. More...
struct	Arageli::type_traits< matrix< T, REFCNT > >
Standard comparision operators.
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
bool	Arageli::operator<= (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
bool	Arageli::operator<= (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
bool	Arageli::operator<= (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
bool	Arageli::operator>= (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
bool	Arageli::operator>= (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
bool	Arageli::operator>= (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
bool	Arageli::operator< (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
bool	Arageli::operator< (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
bool	Arageli::operator< (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
bool	Arageli::operator> (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
bool	Arageli::operator> (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
bool	Arageli::operator> (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
bool	Arageli::operator== (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
bool	Arageli::operator== (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
bool	Arageli::operator== (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
bool	Arageli::operator!= (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
bool	Arageli::operator!= (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
bool	Arageli::operator!= (const T1 &a, const matrix< T2, REFCNT2 > &b)
Binary operators with matrices and scalars.
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix< T1, REFCNT1 >	Arageli::operator+ (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
matrix< T1, REFCNT1 >	Arageli::operator+ (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	Arageli::operator+ (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< T1, REFCNT1 >	Arageli::operator+ (const matrix< T1, REFCNT1 > &a, const T1 &b)
template<typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	Arageli::operator+ (const T2 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< rational< T1 >, REFCNT1 >	Arageli::operator+ (const matrix< rational< T1 >, REFCNT1 > &a, const rational< T1 > &b)
template<typename T2, bool REFCNT2>
matrix< rational< T2 >, REFCNT2 >	Arageli::operator+ (const rational< T2 > &a, const matrix< rational< T2 >, REFCNT2 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	Arageli::operator+ (const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &a, const sparse_polynom< T1, D1, REFCNT1 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	Arageli::operator+ (const sparse_polynom< T1, D1, REFCNT1 > &a, const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix< T1, REFCNT1 >	Arageli::operator- (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
matrix< T1, REFCNT1 >	Arageli::operator- (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	Arageli::operator- (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< T1, REFCNT1 >	Arageli::operator- (const matrix< T1, REFCNT1 > &a, const T1 &b)
template<typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	Arageli::operator- (const T2 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< rational< T1 >, REFCNT1 >	Arageli::operator- (const matrix< rational< T1 >, REFCNT1 > &a, const rational< T1 > &b)
template<typename T2, bool REFCNT2>
matrix< rational< T2 >, REFCNT2 >	Arageli::operator- (const rational< T2 > &a, const matrix< rational< T2 >, REFCNT2 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	Arageli::operator- (const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &a, const sparse_polynom< T1, D1, REFCNT1 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	Arageli::operator- (const sparse_polynom< T1, D1, REFCNT1 > &a, const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix< T1, REFCNT1 >	Arageli::operator * (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
matrix< T1, REFCNT1 >	Arageli::operator * (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	Arageli::operator * (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< T1, REFCNT1 >	Arageli::operator * (const matrix< T1, REFCNT1 > &a, const T1 &b)
template<typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	Arageli::operator * (const T2 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< rational< T1 >, REFCNT1 >	Arageli::operator * (const matrix< rational< T1 >, REFCNT1 > &a, const rational< T1 > &b)
template<typename T2, bool REFCNT2>
matrix< rational< T2 >, REFCNT2 >	Arageli::operator * (const rational< T2 > &a, const matrix< rational< T2 >, REFCNT2 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	Arageli::operator * (const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &a, const sparse_polynom< T1, D1, REFCNT1 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	Arageli::operator * (const sparse_polynom< T1, D1, REFCNT1 > &a, const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix< T1, REFCNT1 >	Arageli::operator/ (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
matrix< T1, REFCNT1 >	Arageli::operator/ (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	Arageli::operator/ (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< T1, REFCNT1 >	Arageli::operator/ (const matrix< T1, REFCNT1 > &a, const T1 &b)
template<typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	Arageli::operator/ (const T2 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< rational< T1 >, REFCNT1 >	Arageli::operator/ (const matrix< rational< T1 >, REFCNT1 > &a, const rational< T1 > &b)
template<typename T2, bool REFCNT2>
matrix< rational< T2 >, REFCNT2 >	Arageli::operator/ (const rational< T2 > &a, const matrix< rational< T2 >, REFCNT2 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	Arageli::operator/ (const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &a, const sparse_polynom< T1, D1, REFCNT1 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	Arageli::operator/ (const sparse_polynom< T1, D1, REFCNT1 > &a, const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix< T1, REFCNT1 >	Arageli::operator% (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
matrix< T1, REFCNT1 >	Arageli::operator% (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	Arageli::operator% (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< T1, REFCNT1 >	Arageli::operator% (const matrix< T1, REFCNT1 > &a, const T1 &b)
template<typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	Arageli::operator% (const T2 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< rational< T1 >, REFCNT1 >	Arageli::operator% (const matrix< rational< T1 >, REFCNT1 > &a, const rational< T1 > &b)
template<typename T2, bool REFCNT2>
matrix< rational< T2 >, REFCNT2 >	Arageli::operator% (const rational< T2 > &a, const matrix< rational< T2 >, REFCNT2 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	Arageli::operator% (const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &a, const sparse_polynom< T1, D1, REFCNT1 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	Arageli::operator% (const sparse_polynom< T1, D1, REFCNT1 > &a, const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix< T1, REFCNT1 >	Arageli::operator & (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
matrix< T1, REFCNT1 >	Arageli::operator & (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	Arageli::operator & (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< T1, REFCNT1 >	Arageli::operator & (const matrix< T1, REFCNT1 > &a, const T1 &b)
template<typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	Arageli::operator & (const T2 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< rational< T1 >, REFCNT1 >	Arageli::operator & (const matrix< rational< T1 >, REFCNT1 > &a, const rational< T1 > &b)
template<typename T2, bool REFCNT2>
matrix< rational< T2 >, REFCNT2 >	Arageli::operator & (const rational< T2 > &a, const matrix< rational< T2 >, REFCNT2 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	Arageli::operator & (const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &a, const sparse_polynom< T1, D1, REFCNT1 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	Arageli::operator & (const sparse_polynom< T1, D1, REFCNT1 > &a, const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix< T1, REFCNT1 >	Arageli::operator| (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
matrix< T1, REFCNT1 >	Arageli::operator| (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	Arageli::operator| (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< T1, REFCNT1 >	Arageli::operator| (const matrix< T1, REFCNT1 > &a, const T1 &b)
template<typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	Arageli::operator| (const T2 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< rational< T1 >, REFCNT1 >	Arageli::operator| (const matrix< rational< T1 >, REFCNT1 > &a, const rational< T1 > &b)
template<typename T2, bool REFCNT2>
matrix< rational< T2 >, REFCNT2 >	Arageli::operator| (const rational< T2 > &a, const matrix< rational< T2 >, REFCNT2 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	Arageli::operator| (const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &a, const sparse_polynom< T1, D1, REFCNT1 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	Arageli::operator| (const sparse_polynom< T1, D1, REFCNT1 > &a, const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix< T1, REFCNT1 >	Arageli::operator^ (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
matrix< T1, REFCNT1 >	Arageli::operator^ (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	Arageli::operator^ (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< T1, REFCNT1 >	Arageli::operator^ (const matrix< T1, REFCNT1 > &a, const T1 &b)
template<typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	Arageli::operator^ (const T2 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< rational< T1 >, REFCNT1 >	Arageli::operator^ (const matrix< rational< T1 >, REFCNT1 > &a, const rational< T1 > &b)
template<typename T2, bool REFCNT2>
matrix< rational< T2 >, REFCNT2 >	Arageli::operator^ (const rational< T2 > &a, const matrix< rational< T2 >, REFCNT2 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	Arageli::operator^ (const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &a, const sparse_polynom< T1, D1, REFCNT1 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	Arageli::operator^ (const sparse_polynom< T1, D1, REFCNT1 > &a, const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix< T1, REFCNT1 >	Arageli::operator<< (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
matrix< T1, REFCNT1 >	Arageli::operator<< (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	Arageli::operator<< (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< T1, REFCNT1 >	Arageli::operator<< (const matrix< T1, REFCNT1 > &a, const T1 &b)
template<typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	Arageli::operator<< (const T2 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< rational< T1 >, REFCNT1 >	Arageli::operator<< (const matrix< rational< T1 >, REFCNT1 > &a, const rational< T1 > &b)
template<typename T2, bool REFCNT2>
matrix< rational< T2 >, REFCNT2 >	Arageli::operator<< (const rational< T2 > &a, const matrix< rational< T2 >, REFCNT2 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	Arageli::operator<< (const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &a, const sparse_polynom< T1, D1, REFCNT1 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	Arageli::operator<< (const sparse_polynom< T1, D1, REFCNT1 > &a, const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix< T1, REFCNT1 >	Arageli::operator>> (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
matrix< T1, REFCNT1 >	Arageli::operator>> (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	Arageli::operator>> (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< T1, REFCNT1 >	Arageli::operator>> (const matrix< T1, REFCNT1 > &a, const T1 &b)
template<typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	Arageli::operator>> (const T2 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< rational< T1 >, REFCNT1 >	Arageli::operator>> (const matrix< rational< T1 >, REFCNT1 > &a, const rational< T1 > &b)
template<typename T2, bool REFCNT2>
matrix< rational< T2 >, REFCNT2 >	Arageli::operator>> (const rational< T2 > &a, const matrix< rational< T2 >, REFCNT2 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	Arageli::operator>> (const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &a, const sparse_polynom< T1, D1, REFCNT1 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	Arageli::operator>> (const sparse_polynom< T1, D1, REFCNT1 > &a, const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &b)
Defines
#define	_ARAGELI_MATRIX_CMP(OPER)
#define	_ARAGELI_GENERIC_MATRIX_OPERATORS1(MNEM, OPERB)
#define	_ARAGELI_GENERIC_MATRIX_OPERATORS2(MNEM)
#define	_ARAGELI_MATRIX_BINARY_BY_UNARY(MNEM, OPERB)
#define	ARAGELI_INCLUDE_CPP_WITH_EXPORT_TEMPLATE_MATRIX
Functions
template<typename T>
void	std::swap (Arageli::_Internal::Rep_matrix< T > &a, Arageli::_Internal::Rep_matrix< T > &b)
template<typename T, bool REFCNT>
matrix< T, true >	Arageli::transpose (const matrix< T, REFCNT > &a)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
int	Arageli::cmp (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
	Lexicographical comparision of two matrix.
template<typename T1, typename T2, typename T3>
T3 &	Arageli::each_add_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::add_matrix_scalar (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::add_scalar_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::each_sub_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::sub_matrix_scalar (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::sub_scalar_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::each_mul_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::mul_matrix_scalar (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::mul_scalar_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::each_div_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::div_matrix_scalar (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::div_scalar_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::each_mod_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::mod_matrix_scalar (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::mod_scalar_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::each_bitand_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::bitand_matrix_scalar (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::bitand_scalar_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::each_bitor_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::bitor_matrix_scalar (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::bitor_scalar_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::each_bitxor_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::bitxor_matrix_scalar (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::bitxor_scalar_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::each_shl_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::shl_matrix_scalar (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::shl_scalar_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::each_shr_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::shr_matrix_scalar (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::shr_scalar_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::mul_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::div_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::add_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::sub_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::mod_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::bitand_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::bitor_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::bitxor_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::shl_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 &	Arageli::shr_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 >	Arageli::operator * (const matrix< T1, REFCNT1 > &m, const vector< T2, REFCNT2 > &x)
	Matrix by vector multiplication.
template<typename T2, bool REFCNT2, typename T1, bool REFCNT1>
vector< T2, REFCNT2 >	Arageli::operator * (const vector< T2, REFCNT2 > &x, const matrix< T1, REFCNT1 > &m)
	Vector by matrix multiplication.
template<typename T, bool REFCNT>
std::ostream &	Arageli::output_list (std::ostream &out, const matrix< T, REFCNT > &x, const char *first_bracket=matrix_output_list_first_bracket_default, const char *second_bracket=matrix_output_list_second_bracket_default, const char *row_separator=matrix_output_list_row_separator_default, const char *first_row_bracket=matrix_output_list_first_row_bracket_default, const char *second_row_bracket=matrix_output_list_second_row_bracket_default, const char *col_separator=matrix_output_list_col_separator_default)
	Simple output of the matrix.
template<typename T, bool REFCNT>
std::istream &	Arageli::input_list (std::istream &out, matrix< T, REFCNT > &x, const char *first_bracket=matrix_input_list_first_bracket_default, const char *second_bracket=matrix_input_list_second_bracket_default, const char *row_separator=matrix_input_list_row_separator_default, const char *first_row_bracket=matrix_input_list_first_row_bracket_default, const char *second_row_bracket=matrix_input_list_second_row_bracket_default, const char *col_separator=matrix_input_list_col_separator_default)
	Simple input of the matrix.
template<typename T, bool REFCNT>
std::ostream &	Arageli::output_aligned (std::ostream &out, const matrix< T, REFCNT > &x, const char *left_col=matrix_output_aligned_left_col_default, const char *right_col=matrix_output_aligned_right_col_default, const char *inter_col=matrix_output_aligned_inter_col_default)
	Aligned output of the matrix.
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
std::ostream &	Arageli::output_aligned_ver_pair (std::ostream &out, const matrix< T1, REFCNT1 > &m1, const matrix< T2, REFCNT2 > &m2, const char *left_col="|| ", const char *right_col=" ||", const char *inter_col=" ", const char *hsplitter="-")
	Vertical aligned output of a pair of matrices.
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
std::ostream &	Arageli::output_aligned_hor_pair (std::ostream &out, const matrix< T1, REFCNT1 > &m1, const matrix< T2, REFCNT2 > &m2, const char *left_col="|| ", const char *right_col=" ||", const char *inter_col=" ", const char *vsplitter=" | ")
	Horizontal aligned output of a pair of matrices.
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename T3, bool REFCNT3>
std::ostream &	Arageli::output_aligned_corner_triplet_br (std::ostream &out, const matrix< T1, REFCNT1 > &m1, const matrix< T2, REFCNT2 > &m2, const matrix< T3, REFCNT3 > &m3, const char *left_col="|| ", const char *right_col=" ||", const char *inter_col=" ", const char *vsplitter=" | ", const char *hsplitter="-")
	Aligned output of a triplet of matrices.
template<typename T, bool REFCNT>
std::ostream &	Arageli::operator<< (std::ostream &out, const matrix< T, REFCNT > &x)
	Standard output routine (default type of outputting) for the matrix.
template<typename T, bool REFCNT>
std::istream &	Arageli::operator>> (std::istream &out, matrix< T, REFCNT > &x)
	Standard input routine (default type of inputting) for the matrix.
template<typename T, bool REFCNT>
std::ofstream &	Arageli::operator<< (std::ofstream &out, const matrix< T, REFCNT > &x)
	WARNING! TEMPORARY DEFINITION!!!
template<typename T, bool REFCNT>
std::ifstream &	Arageli::operator>> (std::ifstream &out, matrix< T, REFCNT > &x)
	WARNING! TEMPORARY DEFINITION!!!
template<typename T, bool REFCNT>
std::ostream &	Arageli::operator<< (std::ostringstream &out, const matrix< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::istream &	Arageli::operator>> (std::istringstream &out, matrix< T, REFCNT > &x)
	Standard input routine (default type of inputting) for the matrix.
template<typename T, bool REFCNT>
matrix< T, REFCNT >	Arageli::opposite (const matrix< T, REFCNT > &x)
template<typename T, bool REFCNT>
matrix< T, REFCNT > &	Arageli::opposite (const matrix< T, REFCNT > &x, matrix< T, REFCNT > *y)
template<typename T, bool REFCNT>
matrix< T, REFCNT > &	Arageli::opposite (matrix< T, REFCNT > *x)
template<typename T, bool REFCNT>
matrix< T, REFCNT > &	Arageli::inverse (const matrix< T, REFCNT > &x, matrix< T, REFCNT > *y)
template<typename T, bool REFCNT>
matrix< T, REFCNT > &	Arageli::inverse (matrix< T, REFCNT > *x)
template<typename T, bool REFCNT>
bool	Arageli::is_unit (const matrix< T, REFCNT > &x)
template<typename T, bool REFCNT>
bool	Arageli::is_opposite_unit (const matrix< T, REFCNT > &x)
template<typename T, bool REFCNT>
bool	Arageli::is_null (const matrix< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::ostream &	Arageli::output_polynom_first (std::ostream &out, const matrix< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::ostream &	Arageli::output_polynom_internal (std::ostream &out, const matrix< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::ostream &	Arageli::output_pow (std::ostream &out, const matrix< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::istream &	Arageli::input_polynom_first (std::istream &in, matrix< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::istream &	Arageli::input_polynom_internal (std::istream &in, matrix< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::istream &	Arageli::input_pow (std::istream &in, matrix< T, REFCNT > &x)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename T3, bool REFCNT3>
void	Arageli::fill_submatrix_col (const matrix< T1, REFCNT1 > &orig, const vector< T2, REFCNT2 > &indexes, matrix< T3, REFCNT3 > &res)
	Makes submatrix from columns of another matrix with particular indexes.
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename T3, bool REFCNT3>
void	Arageli::fill_submatrix_row (const matrix< T1, REFCNT1 > &orig, const vector< T2, REFCNT2 > &indexes, matrix< T3, REFCNT3 > &res)
	Makes submatrix from rows of another matrix with particular indexes.
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
void	std::swap (Arageli::matrix< T1, REFCNT1 > &a, Arageli::matrix< T2, REFCNT2 > &b)
	Swaps two matrix without actully copying (if possible).
template<typename T1, bool REFCNT1>
void	std::swap (Arageli::matrix< T1, REFCNT1 > &a, Arageli::matrix< T1, REFCNT1 > &b)
	Swaps two matrix without actully copying (if possible).
Variables
const colwise_t	Arageli::colwise = colwise_t()
	Helper object for columnwise filling of the matrix.
const diag_t	Arageli::diag = diag_t()
	Helper object for construct a diagonal matrix.
const eye_t	Arageli::eye = eye_t()
	Helper object for construct an indentity matrix.
const frommat_t	Arageli::frommat = frommat_t()
const char *	Arageli::matrix_output_list_first_bracket_default
const char *	Arageli::matrix_output_list_second_bracket_default
const char *	Arageli::matrix_output_list_row_separator_default
const char *	Arageli::matrix_output_list_first_row_bracket_default
const char *	Arageli::matrix_output_list_second_row_bracket_default
const char *	Arageli::matrix_output_list_col_separator_default
const char *	Arageli::matrix_input_list_first_bracket_default
const char *	Arageli::matrix_input_list_second_bracket_default
const char *	Arageli::matrix_input_list_row_separator_default
const char *	Arageli::matrix_input_list_first_row_bracket_default
const char *	Arageli::matrix_input_list_second_row_bracket_default
const char *	Arageli::matrix_input_list_col_separator_default
const char *	Arageli::matrix_output_aligned_left_col_default
const char *	Arageli::matrix_output_aligned_right_col_default
const char *	Arageli::matrix_output_aligned_inter_col_default

---

Detailed Description

Template class matrix definition and relative operations. This file contains template class matrix, relative nonmember functions and a specialization of type_traits common template for the matrix class.

This file contains only declarations of all noninline operations. Implementation of other operations see in matrix.cpp file.

Indexes of entries in a matrix begin from zero.

Definition in file matrix.hpp.

---

Define Documentation

#define _ARAGELI_GENERIC_MATRIX_OPERATORS1	(	MNEM,
		OPERB		)

Definition at line 2796 of file matrix.hpp.

#define _ARAGELI_GENERIC_MATRIX_OPERATORS2

(

MNEM

)

Value:

template <typename T1, typename T2, typename T3>                \
T3& MNEM##_matrix_matrix (const T1& a, const T2& b, T3& res)    \
{ return each_##MNEM##_matrix_matrix(a, b, res); }

Definition at line 2854 of file matrix.hpp.

#define _ARAGELI_MATRIX_BINARY_BY_UNARY	(	MNEM,
		OPERB		)

Definition at line 2882 of file matrix.hpp.

#define _ARAGELI_MATRIX_CMP

(

OPER

)

Definition at line 2740 of file matrix.hpp.

#define ARAGELI_INCLUDE_CPP_WITH_EXPORT_TEMPLATE_MATRIX

Definition at line 3590 of file matrix.hpp.

---