Boost C++ 库

...世界上最受推崇和设计最精良的 C++ 库项目之一。 — Herb Sutter 和 Andrei Alexandrescu, C++ 编码标准

矩阵表达式

矩阵表达式

描述

模板类 matrix_expression<E> 必须是所有建模矩阵表达式概念的类的公共基类。

定义

定义于头文件 expression_types.hpp 中。

模板参数

参数 描述 默认值
E 矩阵表达式的类型。  

模型

无。不是矩阵表达式！

类型要求

无。

公共基类

无。

成员

成员 描述
const expression_type &operator () () const 返回表达式的 const 引用。
expression_type &operator () () 返回表达式的引用。

注释

operator[]、row、column、range、slice 和 project 函数已被移除。请使用在 matrix proxy 中定义的自由函数代替。

矩阵容器

描述

模板类 matrix_container<C> 必须是所有建模矩阵概念的类的公共基类。这包括类 matrix 本身。

定义

定义于头文件 expression_types.hpp 中。

模板参数

参数 描述 默认值
E 矩阵表达式的类型。  

模型

无。不是矩阵表达式或矩阵！

类型要求

无。

公共基类

matrix_expression<C>

成员

成员 描述
const container_type &operator () () const 返回容器的 const 引用。
container_type &operator () () 返回容器的引用。

矩阵引用

引用

描述

模板类 matrix_reference<E> 包含对矩阵表达式的引用。

定义

定义于头文件 matrix_expression.hpp 中。

模板参数

参数 描述 默认值
E 矩阵表达式的类型。  

模型

矩阵表达式 .

类型要求

无，除了 矩阵表达式 的要求所施加的那些。

公共基类

matrix_expression<matrix_reference<E> >

成员

成员 描述
matrix_reference (expression_type &e) 构造表达式的常量引用。
void resize (size_type size1, size2) 调整表达式大小以容纳最多 size1 行，每行 size2 个元素。
size_type size1 () const 返回行数。
size_type size2 () const 返回列数。
const_reference operator () (size_type i, size_type j) const 返回第 i 行中第 j 个元素的值。
reference operator () (size_type i, size_type j) 返回第 i 行中第 j 个元素的引用。
const_iterator1 begin1 () const 返回指向表达式开头的 const_iterator1。
const_iterator1 end1 () const 返回指向表达式末尾的 const_iterator1。
iterator1 begin1 () 返回指向表达式开头的 iterator1。
iterator1 end1 () 返回指向表达式末尾的 iterator1。
const_iterator2 begin2 () const 返回指向表达式开头的 const_iterator2。
const_iterator2 end2 () const 返回指向表达式末尾的 const_iterator2。
iterator2 begin2 () 返回指向表达式开头的 iterator2。
iterator2 end2 () 返回指向表达式末尾的 iterator2。
const_reverse_iterator1 rbegin1 () const 返回指向反向表达式开头的 const_reverse_iterator1。
const_reverse_iterator1 rend1 () const 返回指向反向表达式末尾的 const_reverse_iterator1。
reverse_iterator1 rbegin1 () 返回指向反向表达式开头的 reverse_iterator1。
reverse_iterator1 rend1 () 返回指向反向表达式末尾的 reverse_iterator1。
const_reverse_iterator2 rbegin2 () const 返回指向反向表达式开头的 const_reverse_iterator2。
const_reverse_iterator2 rend2 () const 返回指向反向表达式末尾的 const_reverse_iterator2。
reverse_iterator2 rbegin2 () 返回指向反向表达式开头的 reverse_iterator2。
reverse_iterator2 rend2 () 返回指向反向表达式末尾的 reverse_iterator2。

矩阵运算

一元运算描述

描述

模板类 matrix_unary1<E, F> 和 matrix_unary2<E, F> 描述了一元矩阵运算。

定义

定义于头文件 matrix_expression.hpp 中。

模板参数

参数 描述 默认值
E 矩阵表达式的类型。  
F 运算的类型。  

模型

矩阵表达式 .

类型要求

无，除了 矩阵表达式 的要求所施加的那些。

公共基类

matrix_expression<matrix_unary1<E, F> > 和 matrix_expression<matrix_unary2<E, F> > 分别。

成员

成员 描述
matrix_unary1 (const expression_type &e) 构造表达式的描述。
matrix_unary2 (const expression_type &e) 构造表达式的描述。
size_type size1 () const 返回行数。
size_type size2 () const 返回列数。
const_reference operator () (size_type i, size_type j) const 返回第 i 行中第 j 个元素的值。
const_iterator1 begin1 () const 返回指向表达式开头的 const_iterator1。
const_iterator1 end1 () const 返回指向表达式末尾的 const_iterator1。
const_iterator2 begin2 () const 返回指向表达式开头的 const_iterator2。
const_iterator2 end2 () const 返回指向表达式末尾的 const_iterator2。
const_reverse_iterator1 rbegin1 () const 返回指向反向表达式开头的 const_reverse_iterator1。
const_reverse_iterator1 rend1 () const 返回指向反向表达式末尾的 const_reverse_iterator1。
const_reverse_iterator2 rbegin2 () const 返回指向反向表达式开头的 const_reverse_iterator2。
const_reverse_iterator2 rend2 () const 返回指向反向表达式末尾的 const_reverse_iterator2。

一元运算

原型

template<class E, class F>
    struct matrix_unary1_traits {
        typedef matrix_unary1<typename E::const_closure_type, F> expression_type;
        typedef expression_type result_type;
     };

    // (- m) [i] [j] = - m [i] [j]
    template<class E>
     typename matrix_unary1_traits<E, scalar_negate<typename E::value_type> >::result_type
    operator - (const matrix_expression<E> &e);

    // (conj m) [i] [j] = conj (m [i] [j])
    template<class E>
     typename matrix_unary1_traits<E, scalar_conj<typename E::value_type> >::result_type
    conj (const matrix_expression<E> &e);

    // (real m) [i] [j] = real (m [i] [j])
    template<class E>
     typename matrix_unary1_traits<E, scalar_real<typename E::value_type> >::result_type
    real (const matrix_expression<E> &e);

    // (imag m) [i] [j] = imag (m [i] [j])
    template<class E>
     typename matrix_unary1_traits<E, scalar_imag<typename E::value_type> >::result_type
    imag (const matrix_expression<E> &e);

    template<class E, class F>
    struct matrix_unary2_traits {
        typedef matrix_unary2<typename E::const_closure_type, F> expression_type;
        typedef expression_type result_type;
     };

    // (trans m) [i] [j] = m [j] [i]
    template<class E>
     typename matrix_unary2_traits<E, scalar_identity<typename E::value_type> >::result_type
    trans (const matrix_expression<E> &e);

    // (herm m) [i] [j] = conj (m [j] [i])
    template<class E>
     typename matrix_unary2_traits<E, scalar_conj<typename E::value_type> >::result_type
    herm (const matrix_expression<E> &e);

描述

operator - 计算矩阵表达式的加法逆元。conj 计算矩阵表达式的复共轭。real 和 imag 计算矩阵表达式的实部和虚部。trans 计算矩阵表达式的转置。herm 计算矩阵表达式的厄米共轭，即转置的复共轭。

定义

定义于头文件 matrix_expression.hpp 中。

类型要求

先决条件

无。

复杂度

二次方，取决于矩阵表达式的大小。

示例

#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/io.hpp>

int main () {
    using namespace boost::numeric::ublas;
    matrix<std::complex<double> > m (3, 3);
    for (unsigned i = 0; i < m.size1 (); ++ i)
        for (unsigned j = 0; j < m.size2 (); ++ j)
            m (i, j) = std::complex<double> (3 * i + j, 3 * i + j);

    std::cout << - m << std::endl;
    std::cout << conj (m) << std::endl;
    std::cout << real (m) << std::endl;
    std::cout << imag (m) << std::endl;
    std::cout << trans (m) << std::endl;
    std::cout << herm (m) << std::endl;
}

二元运算描述

描述

模板类 matrix_binary<E1, E2, F> 描述了二元矩阵运算。

定义

定义于头文件 matrix_expression.hpp 中。

模板参数

参数 描述 默认值
E1 第一个矩阵表达式的类型。
E2 第二个矩阵表达式的类型。
F 运算的类型。

模型

矩阵表达式 .

类型要求

无，除了 矩阵表达式 的要求所施加的那些。

公共基类

matrix_expression<matrix_binary<E1, E2, F> >.

成员

成员 描述
matrix_binary (const expression1_type &e1, const expression2_type &e2) 构造表达式的描述。
size_type size1 () const 返回行数。
size_type size2 () const 返回列数。
const_reference operator () (size_type i, size_type j) const 返回第 i 行中第 j 个元素的值。
const_iterator1 begin1 () const 返回指向表达式开头的 const_iterator1。
const_iterator1 end1 () const 返回指向表达式末尾的 const_iterator1。
const_iterator2 begin2 () const 返回指向表达式开头的 const_iterator2。
const_iterator2 end2 () const 返回指向表达式末尾的 const_iterator2。
const_reverse_iterator1 rbegin1 () const 返回指向反向表达式开头的 const_reverse_iterator1。
const_reverse_iterator1 rend1 () const 返回指向反向表达式末尾的 const_reverse_iterator1。
const_reverse_iterator2 rbegin2 () const 返回指向反向表达式开头的 const_reverse_iterator2。
const_reverse_iterator2 rend2 () const 返回指向反向表达式末尾的 const_reverse_iterator2。

二元运算

原型

template<class E1, class E2, class F>
    struct matrix_binary_traits {
        typedef matrix_binary<typename E1::const_closure_type,
                               typename E2::const_closure_type, F> expression_type;
        typedef expression_type result_type;
     };

    // (m1 + m2) [i] [j] = m1 [i] [j] + m2 [i] [j]
    template<class E1, class E2>
    typename matrix_binary_traits<E1, E2, scalar_plus<typename E1::value_type,
                                                       typename E2::value_type> >::result_type
    operator + (const matrix_expression<E1> &e1,
                 const matrix_expression<E2> &e2);

    // (m1 - m2) [i] [j] = m1 [i] [j] - m2 [i] [j]
    template<class E1, class E2>
    typename matrix_binary_traits<E1, E2, scalar_minus<typename E1::value_type,
                                                        typename E2::value_type> >::result_type
    operator - (const matrix_expression<E1> &e1,
                 const matrix_expression<E2> &e2);

描述

operator + 计算两个矩阵表达式的和。operator - 计算两个矩阵表达式的差。

定义

定义于头文件 matrix_expression.hpp 中。

类型要求

先决条件

复杂度

二次方，取决于矩阵表达式的大小。

示例

#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/io.hpp>

int main () {
    using namespace boost::numeric::ublas;
    matrix<double> m1 (3, 3), m2 (3, 3);
    for (unsigned i = 0; i < std::min (m1.size1 (), m2.size1 ()); ++ i)
        for (unsigned j = 0; j < std::min (m1.size2 (), m2.size2 ()); ++ j)
            m1 (i, j) = m2 (i, j) = 3 * i + j;

    std::cout << m1 + m2 << std::endl;
    std::cout << m1 - m2 << std::endl;
}

标量矩阵运算描述

描述

模板类 matrix_binary_scalar1<E1, E2, F> 和 matrix_binary_scalar2<E1, E2, F> 描述了标量和矩阵之间的二元运算。

定义

定义于头文件 matrix_expression.hpp 中。

模板参数

参数 描述 默认值
E1/E2 标量表达式的类型。
E2/E1 矩阵表达式的类型。
F 运算的类型。

模型

矩阵表达式 .

类型要求

无，除了 矩阵表达式 的要求所施加的那些。

公共基类

matrix_expression<matrix_binary_scalar1<E1, E2, F> > 和 matrix_expression<matrix_binary_scalar2<E1, E2, F> > 分别。

成员

成员 描述
matrix_binary_scalar1 (const expression1_type &e1, const expression2_type &e2) 构造表达式的描述。
matrix_binary_scalar1 (const expression1_type &e1, const expression2_type &e2) 构造表达式的描述。
size_type size1 () const 返回行数。
size_type size2 () const 返回列数。
const_reference operator () (size_type i, size_type j) const 返回第 i 行中第 j 个元素的值。
const_iterator1 begin1 () const 返回指向表达式开头的 const_iterator1。
const_iterator1 end1 () const 返回指向表达式末尾的 const_iterator1。
const_iterator2 begin2 () const 返回指向表达式开头的 const_iterator2。
const_iterator2 end2 () const 返回指向表达式末尾的 const_iterator2。
const_reverse_iterator1 rbegin1 () const 返回指向反向表达式开头的 const_reverse_iterator1。
const_reverse_iterator1 rend1 () const 返回指向反向表达式末尾的 const_reverse_iterator1。
const_reverse_iterator2 rbegin2 () const 返回指向反向表达式开头的 const_reverse_iterator2。
const_reverse_iterator2 rend2 () const 返回指向反向表达式末尾的 const_reverse_iterator2。

标量矩阵运算

原型

template<class T1, class E2, class F>
    struct matrix_binary_scalar1_traits {
        typedef matrix_binary_scalar1<scalar_const_reference<T1>,
                                      typename E2::const_closure_type, F> expression_type;
        typedef expression_type result_type;
     };

    // (t * m) [i] [j] = t * m [i] [j]
    template<class T1, class E2>
    typename matrix_binary_scalar1_traits<T1, E2, scalar_multiplies<T1, typename E2::value_type> >::result_type
    operator * (const T1 &e1,
                 const matrix_expression<E2> &e2);

    template<class E1, class T2, class F>
    struct matrix_binary_scalar2_traits {
        typedef matrix_binary_scalar2<typename E1::const_closure_type,
                                      scalar_const_reference<T2>, F> expression_type;
        typedef expression_type result_type;
     };

    // (m * t) [i] [j] = m [i] [j] * t
    template<class E1, class T2>
    typename matrix_binary_scalar2_traits<E1, T2, scalar_multiplies<typename E1::value_type, T2> >::result_type
    operator * (const matrix_expression<E1> &e1,
                 const T2 &e2);

    // (m / t) [i] [j] = m [i] [j] / t
    template<class E1, class T2>
    typename matrix_binary_scalar2_traits<E1, T2, scalar_divides<typename E1::value_type, T2> >::result_type
    operator / (const matrix_expression<E1> &e1,
                 const T2 &e2);

描述

operator * 计算标量和矩阵表达式的乘积。operator / 将矩阵乘以标量的倒数。

定义

定义于头文件 matrix_expression.hpp 中。

类型要求

先决条件

无。

复杂度

二次方，取决于矩阵表达式的大小。

示例

#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/io.hpp>

int main () {
    using namespace boost::numeric::ublas;
    matrix<double> m (3, 3);
    for (unsigned i = 0; i < m.size1 (); ++ i)
        for (unsigned j = 0; j < m.size2 (); ++ j)
            m (i, j) = 3 * i + j;

    std::cout << 2.0 * m << std::endl;
    std::cout << m * 2.0 << std::endl;
}

矩阵向量运算

二元运算描述

描述

模板类 matrix_vector_binary1<E1, E2, F> 和 matrix_vector_binary2<E1, E2, F> 描述了二元矩阵向量运算。

定义

定义于头文件 matrix_expression.hpp 中。

模板参数

参数 描述 默认值
E1 矩阵或向量表达式的类型。
E2 向量或矩阵表达式的类型。
F 运算的类型。

模型

向量表达式 .

类型要求

无，除了 向量表达式 的要求所施加的那些。

公共基类

vector_expression<matrix_vector_binary1<E1, E2, F> > 和 vector_expression<matrix_vector_binary2<E1, E2, F> > 分别。

成员

成员 描述
matrix_vector_binary1 (const expression1_type &e1, const expression2_type &e2) 构造表达式的描述。
matrix_vector_binary2 (const expression1_type &e1, const expression2_type &e2) 构造表达式的描述。
size_type size () const 返回表达式的大小。
const_reference operator () (size_type i) const 返回第 i 个元素的值。
const_iterator begin () const 返回指向表达式开头的 const_iterator。
const_iterator end () const 返回指向表达式末尾的 const_iterator。
const_reverse_iterator rbegin () const 返回指向反向表达式开头的 const_reverse_iterator。
const_reverse_iterator rend () const 返回指向反向表达式末尾的 const_reverse_iterator。

二元运算

原型

template<class T1, class E1, class T2, class E2>
    struct matrix_vector_binary1_traits {
        typedef row_major_tag dispatch_category;
        typedef typename promote_traits<T1, T2>::promote_type promote_type;
        typedef matrix_vector_binary1<typename E1::const_closure_type,
                                       typename E2::const_closure_type,
                                       matrix_vector_prod1<T1, T2, promote_type> > expression_type;
        typedef expression_type result_type;
     };

    template<class E1, class E2>
    typename matrix_vector_binary1_traits<typename E1::value_type, E1,
                                           typename E2::value_type, E2>::result_type
    prod (const matrix_expression<E1> &e1,
           const vector_expression<E2> &e2,
          row_major_tag);

    // Dispatcher
    template<class E1, class E2>
    typename matrix_vector_binary1_traits<typename E1::value_type, E1,
                                           typename E2::value_type, E2>::result_type
    prod (const matrix_expression<E1> &e1,
           const vector_expression<E2> &e2);

    template<class E1, class E2>
    typename matrix_vector_binary1_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
                                           typename type_traits<typename E2::value_type>::precision_type, E2>::result_type
    prec_prod (const matrix_expression<E1> &e1,
                const vector_expression<E2> &e2,
               row_major_tag);

    // Dispatcher
    template<class E1, class E2>
    typename matrix_vector_binary1_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
                                           typename type_traits<typename E2::value_type>::precision_type, E2>::result_type
    prec_prod (const matrix_expression<E1> &e1,
                const vector_expression<E2> &e2);

    template<class V, class E1, class E2>
    V
    prod (const matrix_expression<E1> &e1,
          const vector_expression<E2> &e2);

    template<class V, class E1, class E2>
    V
    prec_prod (const matrix_expression<E1> &e1,
               const vector_expression<E2> &e2);

    template<class T1, class E1, class T2, class E2>
    struct matrix_vector_binary2_traits {
        typedef column_major_tag dispatch_category;
        typedef typename promote_traits<T1, T2>::promote_type promote_type;
        typedef matrix_vector_binary2<typename E1::const_closure_type,
                                       typename E2::const_closure_type,
                                       matrix_vector_prod2<T1, T2, promote_type> > expression_type;
        typedef expression_type result_type;
     };

    template<class E1, class E2>
    typename matrix_vector_binary2_traits<typename E1::value_type, E1,
                                           typename E2::value_type, E2>::result_type
    prod (const vector_expression<E1> &e1,
           const matrix_expression<E2> &e2,
          column_major_tag);

    // Dispatcher
    template<class E1, class E2>
    typename matrix_vector_binary2_traits<typename E1::value_type, E1,
                                           typename E2::value_type, E2>::result_type
    prod (const vector_expression<E1> &e1,
           const matrix_expression<E2> &e2);

    template<class E1, class E2>
    typename matrix_vector_binary2_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
                                           typename type_traits<typename E2::value_type>::precision_type, E2>::result_type
    prec_prod (const vector_expression<E1> &e1,
                const matrix_expression<E2> &e2,
               column_major_tag);

    // Dispatcher
    template<class E1, class E2>
    typename matrix_vector_binary2_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
                                           typename type_traits<typename E2::value_type>::precision_type, E2>::result_type
    prec_prod (const vector_expression<E1> &e1,
                const matrix_expression<E2> &e2);

    template<class V, class E1, class E2>
    V
    prod (const vector_expression<E1> &e1,
          const matrix_expression<E2> &e2);

    template<class V, class E1, class E2>
    V
    prec_prod (const vector_expression<E1> &e1,
               const matrix_expression<E2> &e2);

描述

prod 计算矩阵和向量表达式的乘积。prec_prod 计算矩阵和向量表达式的双精度乘积。

定义

定义于头文件 matrix_expression.hpp 中。

类型要求

先决条件

复杂度

二次方，取决于矩阵表达式的大小。

示例

#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/io.hpp>

int main () {
    using namespace boost::numeric::ublas;
    matrix<double> m (3, 3);
    vector<double> v (3);
    for (unsigned i = 0; i < std::min (m.size1 (), v.size ()); ++ i) {
        for (unsigned j = 0; j < m.size2 (); ++ j)
            m (i, j) = 3 * i + j;
        v (i) = i;
    }

    std::cout << prod (m, v) << std::endl;
    std::cout << prod (v, m) << std::endl;
}

三角求解器

原型

template<class E1, class E2>
    struct matrix_vector_solve_traits {
        typedef typename promote_traits<typename E1::value_type, typename E2::value_type>::promote_type promote_type;
        typedef vector<promote_type> result_type;
    };

    template<class E1, class E2>
    void inplace_solve (const matrix_expression<E1> &e1,
                         E2 &e2,
                        lower_tag,
                        vector_tag);
    template<class E1, class E2>
    void inplace_solve (const matrix_expression<E1> &e1,
                         E2 &e2,
                        upper_tag,
                        vector_tag);
    template<class E1, class E2>
    void inplace_solve (const matrix_expression<E1> &e1,
                         E2 &e2,
                        unit_lower_tag,
                        vector_tag);
    template<class E1, class E2>
    void inplace_solve (const matrix_expression<E1> &e1,
                         E2 &e2,
                        unit_upper_tag,
                        vector_tag);

    template<class E1, class E2, class C>
    typename matrix_vector_solve_traits<E1, E2>::result_type
    solve (const matrix_expression<E1> &e1,
            const vector_expression<E2> &e2,
           C);

    template<class E1, class E2>
    void inplace_solve (E1 &e1,
                        const matrix_expression<E2> &e2,
                         vector_tag,
                         lower_tag);
    template<class E1, class E2>
    void inplace_solve (E1 &e1,
                        const matrix_expression<E2> &e2,
                         vector_tag,
                         upper_tag);
    template<class E1, class E2>
    void inplace_solve (E1 &e1,
                        const matrix_expression<E2> &e2,
                         vector_tag,
                         unit_lower_tag);
    template<class E1, class E2>
    void inplace_solve (E1 &e1,
                        const matrix_expression<E2> &e2,
                         vector_tag,
                         unit_upper_tag);

    template<class E1, class E2, class C>
    typename matrix_vector_solve_traits<E1, E2>::result_type
    solve (const vector_expression<E1> &e1,
            const matrix_expression<E2> &e2,
           C);

描述

solve 求解下三角或上三角（单位）矩阵的线性方程。

定义

定义于头文件 triangular.hpp 中。

类型要求

先决条件

复杂度

二次方，取决于矩阵表达式的大小。

示例

#include <boost/numeric/ublas/triangular.hpp>
#include <boost/numeric/ublas/io.hpp>

int main () {
    using namespace boost::numeric::ublas;
    matrix<double> m (3, 3);
    vector<double> v (3);
    for (unsigned i = 0; i < std::min (m.size1 (), v.size ()); ++ i) {
        for (unsigned j = 0; j <= i; ++ j)
            m (i, j) = 3 * i + j + 1;
        v (i) = i;
    }

    std::cout << solve (m, v, lower_tag ()) << std::endl;
    std::cout << solve (v, m, lower_tag ()) << std::endl;
}

矩阵矩阵运算

二元运算描述

描述

模板类 matrix_matrix_binary<E1, E2, F> 描述了二元矩阵运算。

定义

定义于头文件 matrix_expression.hpp 中。

模板参数

参数 描述 默认值
E1 第一个矩阵表达式的类型。
E2 第二个矩阵表达式的类型。
F 运算的类型。

模型

矩阵表达式 .

类型要求

无，除了 矩阵表达式 的要求所施加的那些。

公共基类

matrix_expression<matrix_matrix_binary<E1, E2, F> > .

成员

成员 描述
matrix_matrix_binary (const expression1_type &e1, const expression2_type &e2) 构造表达式的描述。
size_type size1 () const 返回行数。
size_type size2 () const 返回列数。
const_reference operator () (size_type i, size_type j) const 返回第 i 行中第 j 个元素的值。
const_iterator1 begin1 () const 返回指向表达式开头的 const_iterator1。
const_iterator1 end1 () const 返回指向表达式末尾的 const_iterator1。
const_iterator2 begin2 () const 返回指向表达式开头的 const_iterator2。
const_iterator2 end2 () const 返回指向表达式末尾的 const_iterator2。
const_reverse_iterator1 rbegin1 () const 返回指向反向表达式开头的 const_reverse_iterator1。
const_reverse_iterator1 rend1 () const 返回指向反向表达式末尾的 const_reverse_iterator1。
const_reverse_iterator2 rbegin2 () const 返回指向反向表达式开头的 const_reverse_iterator2。
const_reverse_iterator2 rend2 () const 返回指向反向表达式末尾的 const_reverse_iterator2。

二元运算

原型

template<class T1, class E1, class T2, class E2>
    struct matrix_matrix_binary_traits {
        typedef unknown_orientation_tag dispatch_category;
        typedef typename promote_traits<T1, T2>::promote_type promote_type;
        typedef matrix_matrix_binary<typename E1::const_closure_type,
                                     typename E2::const_closure_type,
                                     matrix_matrix_prod<T1, T2, promote_type> > expression_type;
        typedef expression_type result_type;
    };

    template<class E1, class E2>
    typename matrix_matrix_binary_traits<typename E1::value_type, E1,
                                         typename E2::value_type, E2>::result_type
    prod (const matrix_expression<E1> &e1,
          const matrix_expression<E2> &e2,
          unknown_orientation_tag);

    // Dispatcher
    template<class E1, class E2>
    typename matrix_matrix_binary_traits<typename E1::value_type, E1,
                                         typename E2::value_type, E2>::result_type
    prod (const matrix_expression<E1> &e1,
          const matrix_expression<E2> &e2);

    template<class E1, class E2>
    typename matrix_matrix_binary_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
                                         typename type_traits<typename E2::value_type>::precision_type, E2>::result_type
    prec_prod (const matrix_expression<E1> &e1,
               const matrix_expression<E2> &e2,
               unknown_orientation_tag);

    // Dispatcher
    template<class E1, class E2>
    typename matrix_matrix_binary_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
                                         typename type_traits<typename E2::value_type>::precision_type, E2>::result_type
    prec_prod (const matrix_expression<E1> &e1,
               const matrix_expression<E2> &e2);

    template<class M, class E1, class E2>
    M
    prod (const matrix_expression<E1> &e1,
          const matrix_expression<E2> &e2);

    template<class M, class E1, class E2>
    M
    prec_prod (const matrix_expression<E1> &e1,
               const matrix_expression<E2> &e2);

描述

prod 计算矩阵表达式的乘积。prec_prod 计算矩阵表达式的双精度乘积。

定义

定义于头文件 matrix_expression.hpp 中。

类型要求

先决条件

复杂度

三次方，取决于矩阵表达式的大小。

示例

#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/io.hpp>

int main () {
    using namespace boost::numeric::ublas;
    matrix<double> m1 (3, 3), m2 (3, 3);
    for (unsigned i = 0; i < std::min (m1.size1 (), m2.size1 ()); ++ i)
        for (unsigned j = 0; j < std::min (m1.size2 (), m2.size2 ()); ++ j)
            m1 (i, j) = m2 (i, j) = 3 * i + j;

    std::cout << prod (m1, m2) << std::endl;
}

三角求解器

原型

template<class E1, class E2>
    struct matrix_matrix_solve_traits {
        typedef typename promote_traits<typename E1::value_type, typename E2::value_type>::promote_type promote_type;
        typedef matrix<promote_type> result_type;
    };

    template<class E1, class E2>
    void inplace_solve (const matrix_expression<E1> &e1,
                        E2 &e2,
                        lower_tag,
                        matrix_tag);
    template<class E1, class E2>
    void inplace_solve (const matrix_expression<E1> &e1,
                        E2 &e2,
                        upper_tag,
                        matrix_tag);
    template<class E1, class E2>
    void inplace_solve (const matrix_expression<E1> &e1,
                        E2 &e2,
                        unit_lower_tag,
                        matrix_tag);
    template<class E1, class E2>
    void inplace_solve (const matrix_expression<E1> &e1,
                        E2 &e2,
                        unit_upper_tag,
                        matrix_tag);

    template<class E1, class E2, class C>
    typename matrix_matrix_solve_traits<E1, E2>::result_type
    solve (const matrix_expression<E1> &e1,
           const matrix_expression<E2> &e2,
           C);

描述

solve 求解下三角或上三角（单位）矩阵的线性方程。

定义

定义于头文件 triangular.hpp 中。

类型要求

先决条件

复杂度

三次方，取决于矩阵表达式的大小。

示例

#include <boost/numeric/ublas/triangular.hpp>
#include <boost/numeric/ublas/io.hpp>

int main () {
    using namespace boost::numeric::ublas;
    matrix<double> m1 (3, 3), m2 (3, 3);
    for (unsigned i = 0; i < std::min (m1.size1 (), m2.size1 ()); ++ i)
        for (unsigned j = 0; j <= i; ++ j)
            m1 (i, j) = m2 (i, j) = 3 * i + j + 1;

    std::cout << solve (m1, m2, lower_tag ()) << std::endl;
}

版权 (©) 2000-2002 Joerg Walter, Mathias Koch
使用、修改和分发受 Boost 软件许可协议 1.0 版的约束。（请参阅随附文件 LICENSE_1_0.txt 或在 https://boost.ac.cn/LICENSE_1_0.txt 复制）。