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.


Generated on Thu Aug 31 17:38:18 2006 for Arageli by  doxygen 1.4.7