Boost C++ 库

...世界上最受尊敬和设计最精良的 C++ 库项目之一。 — Herb Sutter 和 Andrei Alexandrescu，《C++ 编码标准》

矩阵代理

矩阵行

描述

模板类 matrix_row<M> 允许寻址矩阵的行。

示例

#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/matrix_proxy.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) {
        matrix_row<matrix<double> > mr (m, i);
        for (unsigned j = 0; j < mr.size (); ++ j)
            mr (j) = 3 * i + j;
        std::cout << mr << std::endl;
    }
}

定义

定义于头文件 matrix_proxy.hpp 中。

模板参数

参数	描述	默认值
`M`	被引用的矩阵类型。

模型

向量表达式 .

如果指定的行落在矩阵的行索引范围之外，则 matrix_row 不是一个良好形成的向量表达式。也就是说，访问矩阵外部的元素是未定义的。

类型要求

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

公共基类

vector_expression<matrix_row<M> >

成员

成员	描述
`matrix_row (matrix_type &data, size_type i)`	构造一个子向量。
`size_type size () const`	返回子向量的大小。
`const_reference operator () (size_type i) const`	返回第 `i` 个元素的值。
`reference operator () (size_type i)`	返回第 `i` 个元素的引用。
`matrix_row &operator = (const matrix_row &mr)`	赋值运算符。
`matrix_row &assign_temporary (matrix_row &mr)`	赋值一个临时对象。可能会改变矩阵行 `mr`。
`template<class AE> matrix_row &operator = (const vector_expression<AE> &ae)`	扩展赋值运算符。
`template<class AE> matrix_row &assign (const vector_expression<AE> &ae)`	将向量表达式赋值给子向量。赋值的左侧和右侧应相互独立。
`template<class AE> matrix_row &operator += (const vector_expression<AE> &ae)`	复合赋值运算符。将向量表达式加到子向量上。
`template<class AE> matrix_row &plus_assign (const vector_expression<AE> &ae)`	将向量表达式加到子向量上。赋值的左侧和右侧应相互独立。
`template<class AE> matrix_row &operator -= (const vector_expression<AE> &ae)`	复合赋值运算符。从子向量中减去向量表达式。
`template<class AE> matrix_row &minus_assign (const vector_expression<AE> &ae)`	从子向量中减去向量表达式。赋值的左侧和右侧应相互独立。
`template<class AT> matrix_row &operator *= (const AT &at)`	复合赋值运算符。将子向量与标量相乘。
`template<class AT> matrix_row &operator /= (const AT &at)`	复合赋值运算符。将子向量除以标量。
`void swap (matrix_row &mr)`	交换子向量的内容。
`const_iterator begin () const`	返回一个指向 `matrix_row` 开头的 `const_iterator`。
`const_iterator end () const`	返回一个指向 `matrix_row` 结尾的 `const_iterator`。
`iterator begin ()`	返回一个指向 `matrix_row` 开头的 `iterator`。
`iterator end ()`	返回一个指向 `matrix_row` 结尾的 `iterator`。
`const_reverse_iterator rbegin () const`	返回一个指向反向 `matrix_row` 开头的 `const_reverse_iterator`。
`const_reverse_iterator rend () const`	返回一个指向反向 `matrix_row` 结尾的 `const_reverse_iterator`。
`reverse_iterator rbegin ()`	返回一个指向反向 `matrix_row` 开头的 `reverse_iterator`。
`reverse_iterator rend ()`	返回一个指向反向 `matrix_row` 结尾的 `reverse_iterator`。

投影

描述

自由函数 row 支持矩阵行的构造。

原型


    template<class M>
    matrix_row<M> row (M &data, std::size_t i);
    template<class M>
    const matrix_row<const M> row (const M &data, std::size_t i);

定义

定义于头文件 matrix_proxy.hpp 中。

类型要求

M 是矩阵表达式的模型。

复杂度

线性复杂度，取决于行的大小。

示例

#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/matrix_proxy.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)
            row (m, i) (j) = 3 * i + j;
        std::cout << row (m, i) << std::endl;
    }
}

矩阵列

描述

模板类 matrix_column<M> 允许寻址矩阵的列。

示例

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

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

定义

定义于头文件 matrix_proxy.hpp 中。

模板参数

参数	描述	默认值
`M`	被引用的矩阵类型。

模型

向量表达式 .

如果指定的列落在矩阵的列索引范围之外，则 matrix_column 不是一个良好形成的向量表达式。也就是说，访问矩阵外部的元素是未定义的。

类型要求

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

公共基类

vector_expression<matrix_column<M> >

成员

成员	描述
`matrix_column (matrix_type &data, size_type j)`	构造一个子向量。
`size_type size () const`	返回子向量的大小。
`const_reference operator () (size_type i) const`	返回第 `i` 个元素的值。
`reference operator () (size_type i)`	返回第 `i` 个元素的引用。
`matrix_column &operator = (const matrix_column &mc)`	赋值运算符。
`matrix_column &assign_temporary (matrix_column &mc)`	赋值一个临时对象。可能会改变矩阵列 `mc`。
`template<class AE> matrix_column &operator = (const vector_expression<AE> &ae)`	扩展赋值运算符。
`template<class AE> matrix_column &assign (const vector_expression<AE> &ae)`	将向量表达式赋值给子向量。赋值的左侧和右侧应相互独立。
`template<class AE> matrix_column &operator += (const vector_expression<AE> &ae)`	复合赋值运算符。将向量表达式加到子向量上。
`template<class AE> matrix_column &plus_assign (const vector_expression<AE> &ae)`	将向量表达式加到子向量上。赋值的左侧和右侧应相互独立。
`template<class AE> matrix_column &operator -= (const vector_expression<AE> &ae)`	复合赋值运算符。从子向量中减去向量表达式。
`template<class AE> matrix_column &minus_assign (const vector_expression<AE> &ae)`	从子向量中减去向量表达式。赋值的左侧和右侧应相互独立。
`template<class AT> matrix_column &operator *= (const AT &at)`	复合赋值运算符。将子向量与标量相乘。
`template<class AT> matrix_column &operator /= (const AT &at)`	复合赋值运算符。将子向量除以标量。
`void swap (matrix_column &mc)`	交换子向量的内容。
`const_iterator begin () const`	返回一个指向 `matrix_column` 开头的 `const_iterator`。
`const_iterator end () const`	返回一个指向 `matrix_column` 结尾的 `const_iterator`。
`iterator begin ()`	返回一个指向 `matrix_column` 开头的 `iterator`。
`iterator end ()`	返回一个指向 `matrix_column` 结尾的 `iterator`。
`const_reverse_iterator rbegin () const`	返回一个指向反向 `matrix_column` 开头的 `const_reverse_iterator`。
`const_reverse_iterator rend () const`	返回一个指向反向 `matrix_column` 结尾的 `const_reverse_iterator`。
`reverse_iterator rbegin ()`	返回一个指向反向 `matrix_column` 开头的 `reverse_iterator`。
`reverse_iterator rend ()`	返回一个指向反向 `matrix_column` 结尾的 `reverse_iterator`。

投影

描述

自由函数 column 支持矩阵列的构造。

原型


    template<class M>
    matrix_column<M> column (M &data, std::size_t j);
    template<class M>
    const matrix_column<const M> column (const M &data, std::size_t j);

定义

定义于头文件 matrix_proxy.hpp 中。

类型要求

M 是矩阵表达式的模型。

复杂度

线性复杂度，取决于列的大小。

示例

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

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

向量范围

描述

模板类 matrix_vector_range<M> 允许寻址矩阵的子向量。

示例

#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/matrix_proxy.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;

    matrix_vector_range<matrix<double> > mvr (m, range (0, 3), range (0, 3));
    std::cout << mvr << std::endl;
}

定义

定义于头文件 matrix_proxy.hpp 中。

模板参数

参数	描述	默认值
`M`	被引用的矩阵类型。

模型

向量表达式 .

如果指定的范围落在矩阵的索引范围之外，则 matrix_vector_range 不是一个良好形成的向量表达式。也就是说，访问矩阵外部的元素是未定义的。

类型要求

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

公共基类

vector_expression<matrix_vector_range<M> >

成员

成员	描述
`matrix_vector_range (matrix_type &data, const range &r1, const range &r2)`	构造一个子向量。
`size_type size () const`	返回子向量的大小。
`const_reference operator () (size_type i) const`	返回第 `i` 个元素的值。
`reference operator () (size_type i)`	返回第 `i` 个元素的引用。
`matrix_vector_range &operator = (const matrix_vector_range &mvr)`	赋值运算符。
`matrix_vector_range &assign_temporary (matrix_vector_range &mvr)`	赋值一个临时对象。可能会改变矩阵向量范围 `mvr`。
`template<class AE> matrix_vector_range &operator = (const vector_expression<AE> &ae)`	扩展赋值运算符。
`template<class AE> matrix_vector_range &assign (const vector_expression<AE> &ae)`	将向量表达式赋值给子向量。赋值的左侧和右侧应相互独立。
`template<class AE> matrix_vector_range &operator += (const vector_expression<AE> &ae)`	复合赋值运算符。将向量表达式加到子向量上。
`template<class AE> matrix_vector_range &plus_assign (const vector_expression<AE> &ae)`	将向量表达式加到子向量上。赋值的左侧和右侧应相互独立。
`template<class AE> matrix_vector_range &operator -= (const vector_expression<AE> &ae)`	复合赋值运算符。从子向量中减去向量表达式。
`template<class AE> matrix_vector_range &minus_assign (const vector_expression<AE> &ae)`	从子向量中减去向量表达式。赋值的左侧和右侧应相互独立。
`template<class AT> matrix_vector_range &operator *= (const AT &at)`	复合赋值运算符。将子向量与标量相乘。
`template<class AT> matrix_vector_range &operator /= (const AT &at)`	复合赋值运算符。将子向量除以标量。
`void swap (matrix_vector_range &mvr)`	交换子向量的内容。
`const_iterator begin () const`	返回一个指向 `matrix_vector_range` 开头的 `const_iterator`。
`const_iterator end () const`	返回一个指向 `matrix_vector_range` 结尾的 `const_iterator`。
`iterator begin ()`	返回一个指向 `matrix_vector_range` 开头的 `iterator`。
`iterator end ()`	返回一个指向 `matrix_vector_range` 结尾的 `iterator`。
`const_reverse_iterator rbegin () const`	返回一个指向反向 `matrix_vector_range` 开头的 `const_reverse_iterator`。
`const_reverse_iterator rend () const`	返回一个指向反向 `matrix_vector_range` 结尾的 `const_reverse_iterator`。
`reverse_iterator rbegin ()`	返回一个指向反向 `matrix_vector_range` 开头的 `reverse_iterator`。
`reverse_iterator rend ()`	返回一个指向反向 `matrix_vector_range` 结尾的 `reverse_iterator`。

向量切片

描述

模板类 matrix_vector_slice<M> 允许寻址矩阵的切片子向量。

示例

#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/matrix_proxy.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;

    matrix_vector_slice<matrix<double> > mvs (m, slice (0, 1, 3), slice (0, 1, 3));
    std::cout << mvs << std::endl;
}

定义

定义于头文件 matrix_proxy.hpp 中。

模板参数

参数	描述	默认值
`M`	被引用的矩阵类型。

模型

向量表达式 .

如果指定的切片落在矩阵的索引范围之外，则 matrix_vector_slice 不是一个良好形成的向量表达式。也就是说，访问矩阵外部的元素是未定义的。

类型要求

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

公共基类

vector_expression<matrix_vector_slice<M> >

成员

成员	描述
`matrix_vector_slice (matrix_type &data, const slice &s1, const slice &s2)`	构造一个子向量。
`size_type size () const`	返回子向量的大小。
`const_reference operator () (size_type i) const`	返回第 `i` 个元素的值。
`reference operator () (size_type i)`	返回第 `i` 个元素的引用。
`matrix_vector_slice &operator = (const matrix_vector_slice &mvs)`	赋值运算符。
`matrix_vector_slice &assign_temporary (matrix_vector_slice &mvs)`	赋值一个临时对象。可能会改变矩阵向量切片 `vs`。
`template<class AE> matrix_vector_slice &operator = (const vector_expression<AE> &ae)`	扩展赋值运算符。
`template<class AE> matrix_vector_slice &assign (const vector_expression<AE> &ae)`	将向量表达式赋值给子向量。赋值的左侧和右侧应相互独立。
`template<class AE> matrix_vector_slice &operator += (const vector_expression<AE> &ae)`	复合赋值运算符。将向量表达式加到子向量上。
`template<class AE> matrix_vector_slice &plus_assign (const vector_expression<AE> &ae)`	将向量表达式加到子向量上。赋值的左侧和右侧应相互独立。
`template<class AE> matrix_vector_slice &operator -= (const vector_expression<AE> &ae)`	复合赋值运算符。从子向量中减去向量表达式。
`template<class AE> matrix_vector_slice &minus_assign (const vector_expression<AE> &ae)`	从子向量中减去向量表达式。赋值的左侧和右侧应相互独立。
`template<class AT> matrix_vector_slice &operator *= (const AT &at)`	复合赋值运算符。将子向量与标量相乘。
`template<class AT> matrix_vector_slice &operator /= (const AT &at)`	复合赋值运算符。将子向量除以标量。
`void swap (matrix_vector_slice &mvs)`	交换子向量的内容。
`const_iterator begin () const`	返回一个指向 `matrix_vector_slice` 开头的 `const_iterator`。
`const_iterator end () const`	返回一个指向 `matrix_vector_slice` 结尾的 `const_iterator`。
`iterator begin ()`	返回一个指向 `matrix_vector_slice` 开头的 `iterator`。
`iterator end ()`	返回一个指向 `matrix_vector_slice` 结尾的 `iterator`。
`const_reverse_iterator rbegin () const`	返回一个指向反向 `matrix_vector_slice` 开头的 `const_reverse_iterator`。
`const_reverse_iterator rend () const`	返回一个指向反向 `matrix_vector_slice` 结尾的 `const_reverse_iterator`。
`reverse_iterator rbegin ()`	返回一个指向反向 `matrix_vector_slice` 开头的 `reverse_iterator`。
`reverse_iterator rend ()`	返回一个指向反向 `matrix_vector_slice` 结尾的 `reverse_iterator`。

矩阵范围

描述

模板类 matrix_range<M> 允许寻址矩阵的子矩阵。

示例

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

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

定义

定义于头文件 matrix_proxy.hpp 中。

模板参数

参数	描述	默认值
`M`	被引用的矩阵类型。

模型

矩阵表达式 .

如果指定的范围落在矩阵的索引范围之外，则 matrix_range 不是一个良好形成的矩阵表达式。也就是说，访问矩阵外部的元素是未定义的。

类型要求

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

公共基类

matrix_expression<matrix_range<M> >

成员

成员	描述
`matrix_range (matrix_type &data, const range &r1, const range &r2)`	构造一个子矩阵。
`size_type start1 () const`	返回第一行的索引。
`size_type size1 () const`	返回行数。
`size_type start2 () 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` 个元素的引用。
`matrix_range &operator = (const matrix_range &mr)`	赋值运算符。
`matrix_range &assign_temporary (matrix_range &mr)`	赋值一个临时对象。可能会改变矩阵范围 `mr`。
`template<class AE> matrix_range &operator = (const matrix_expression<AE> &ae)`	扩展赋值运算符。
`template<class AE> matrix_range &assign (const matrix_expression<AE> &ae)`	将矩阵表达式赋值给子矩阵。赋值的左侧和右侧应相互独立。
`template<class AE> matrix_range &operator += (const matrix_expression<AE> &ae)`	复合赋值运算符。将矩阵表达式加到子矩阵上。
`template<class AE> matrix_range &plus_assign (const matrix_expression<AE> &ae)`	将矩阵表达式加到子矩阵上。赋值的左侧和右侧应相互独立。
`template<class AE> matrix_range &operator -= (const matrix_expression<AE> &ae)`	复合赋值运算符。从子矩阵中减去矩阵表达式。
`template<class AE> matrix_range &minus_assign (const matrix_expression<AE> &ae)`	从子矩阵中减去矩阵表达式。赋值的左侧和右侧应相互独立。
`template<class AT> matrix_range &operator *= (const AT &at)`	复合赋值运算符。将子矩阵与标量相乘。
`template<class AT> matrix_range &operator /= (const AT &at)`	复合赋值运算符。将子矩阵除以标量。
`void swap (matrix_range &mr)`	交换子矩阵的内容。
`const_iterator1 begin1 () const`	返回一个指向 `matrix_range` 开头的 `const_iterator1`。
`const_iterator1 end1 () const`	返回一个指向 `matrix_range` 结尾的 `const_iterator1`。
`iterator1 begin1 ()`	返回一个指向 `matrix_range` 开头的 `iterator1`。
`iterator1 end1 ()`	返回一个指向 `matrix_range` 结尾的 `iterator1`。
`const_iterator2 begin2 () const`	返回一个指向 `matrix_range` 开头的 `const_iterator2`。
`const_iterator2 end2 () const`	返回一个指向 `matrix_range` 结尾的 `const_iterator2`。
`iterator2 begin2 ()`	返回一个指向 `matrix_range` 开头的 `iterator2`。
`iterator2 end2 ()`	返回一个指向 `matrix_range` 结尾的 `iterator2`。
`const_reverse_iterator1 rbegin1 () const`	返回一个指向反向 `matrix_range` 开头的 `const_reverse_iterator1`。
`const_reverse_iterator1 rend1 () const`	返回一个指向反向 `matrix_range` 结尾的 `const_reverse_iterator1`。
`reverse_iterator1 rbegin1 ()`	返回一个指向反向 `matrix_range` 开头的 `reverse_iterator1`。
`reverse_iterator1 rend1 ()`	返回一个指向反向 `matrix_range` 结尾的 `reverse_iterator1`。
`const_reverse_iterator2 rbegin2 () const`	返回一个指向反向 `matrix_range` 开头的 `const_reverse_iterator2`。
`const_reverse_iterator2 rend2 () const`	返回一个指向反向 `matrix_range` 结尾的 `const_reverse_iterator2`。
`reverse_iterator2 rbegin2 ()`	返回一个指向反向 `matrix_range` 开头的 `reverse_iterator2`。
`reverse_iterator2 rend2 ()`	返回一个指向反向 `matrix_range` 结尾的 `reverse_iterator2`。

简单投影

描述

自由函数 subrange 支持矩阵范围的构造。

原型


    template<class M>
    matrix_range<M> subrange (M &data,
       M::size_type start1, M::size_type stop1, M::size_type start2, M::size_type, stop2);
    template<class M>
    const matrix_range<const M> subrange (const M &data,
       M::size_type start1, M::size_type stop1, M::size_type start2, M::size_type, stop2);

通用投影

描述

自由函数 project 支持矩阵范围的构造。现有的 matrix_range 可以与进一步的范围组合。结果范围使用现有范围的 compose 函数计算。

原型


    template<class M>
    matrix_range<M> project (M &data, const range &r1, const range &r2);
    template<class M>
    const matrix_range<const M> project (const M &data, const range &r1, const range &r2);
    template<class M>
    matrix_range<M> project (matrix_range<M> &data, const range &r1, const range &r2);
    template<class M>
    const matrix_range<M> project (const matrix_range<M> &data, const range &r1, const range &r2);

定义

定义于头文件 matrix_proxy.hpp 中。

类型要求

M 是矩阵表达式的模型。

复杂度

二次复杂度，取决于范围的大小。

示例

#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/matrix_proxy.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)
            project (m, range (0, 3), range (0, 3)) (i, j) = 3 * i + j;
    std::cout << project (m, range (0, 3), range (0, 3)) << std::endl;
}

矩阵切片

描述

模板类 matrix_slice<M> 允许寻址矩阵的切片子矩阵。

示例

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

int main () {
    using namespace boost::numeric::ublas;
    matrix<double> m (3, 3);
    matrix_slice<matrix<double> > ms (m, slice (0, 1, 3), slice (0, 1, 3));
    for (unsigned i = 0; i < ms.size1 (); ++ i)
        for (unsigned j = 0; j < ms.size2 (); ++ j)
            ms (i, j) = 3 * i + j;
    std::cout << ms << std::endl;
}

定义

定义于头文件 matrix_proxy.hpp 中。

模板参数

参数	描述	默认值
`M`	被引用的矩阵类型。

模型

矩阵表达式 .

如果指定的切片落在矩阵的索引范围之外，则 matrix_slice 不是一个良好形成的矩阵表达式。也就是说，访问矩阵外部的元素是未定义的。

类型要求

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

公共基类

matrix_expression<matrix_slice<M> >

成员

成员	描述
`matrix_slice (matrix_type &data, const slice &s1, const slice &s2)`	构造一个子矩阵。
`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` 个元素的引用。
`matrix_slice &operator = (const matrix_slice &ms)`	赋值运算符。
`matrix_slice &assign_temporary (matrix_slice &ms)`	赋值一个临时对象。可能会改变矩阵切片 `ms`。
`template<class AE> matrix_slice &operator = (const matrix_expression<AE> &ae)`	扩展赋值运算符。
`template<class AE> matrix_slice &assign (const matrix_expression<AE> &ae)`	将矩阵表达式赋值给子矩阵。赋值的左侧和右侧应相互独立。
`template<class AE> matrix_slice &operator += (const matrix_expression<AE> &ae)`	复合赋值运算符。将矩阵表达式加到子矩阵上。
`template<class AE> matrix_slice &plus_assign (const matrix_expression<AE> &ae)`	将矩阵表达式加到子矩阵上。赋值的左侧和右侧应相互独立。
`template<class AE> matrix_slice &operator -= (const matrix_expression<AE> &ae)`	复合赋值运算符。从子矩阵中减去矩阵表达式。
`template<class AE> matrix_slice &minus_assign (const matrix_expression<AE> &ae)`	从子矩阵中减去矩阵表达式。赋值的左侧和右侧应相互独立。
`template<class AT> matrix_slice &operator *= (const AT &at)`	复合赋值运算符。将子矩阵与标量相乘。
`template<class AT> matrix_slice &operator /= (const AT &at)`	复合赋值运算符。将子矩阵与标量相乘。
`void swap (matrix_slice &ms)`	交换子矩阵的内容。
`const_iterator1 begin1 () const`	返回一个指向 `matrix_slice` 开头的 `const_iterator1`。
`const_iterator1 end1 () const`	返回一个指向 `matrix_slice` 结尾的 `const_iterator1`。
`iterator1 begin1 ()`	返回一个指向 `matrix_slice` 开头的 `iterator1`。
`iterator1 end1 ()`	返回一个指向 `matrix_slice` 结尾的 `iterator1`。
`const_iterator2 begin2 () const`	返回一个指向 `matrix_slice` 开头的 `const_iterator2`。
`const_iterator2 end2 () const`	返回一个指向 `matrix_slice` 结尾的 `const_iterator2`。
`iterator2 begin2 ()`	返回一个指向 `matrix_slice` 开头的 `iterator2`。
`iterator2 end2 ()`	返回一个指向 `matrix_slice` 结尾的 `iterator2`。
`const_reverse_iterator1 rbegin1 () const`	返回一个指向反向 `matrix_slice` 开头的 `const_reverse_iterator1`。
`const_reverse_iterator1 rend1 () const`	返回一个指向反向 `matrix_slice` 结尾的 `const_reverse_iterator1`。
`reverse_iterator1 rbegin1 ()`	返回一个指向反向 `matrix_slice` 开头的 `reverse_iterator1`。
`reverse_iterator1 rend1 ()`	返回一个指向反向 `matrix_slice` 结尾的 `reverse_iterator1`。
`const_reverse_iterator2 rbegin2 () const`	返回一个指向反向 `matrix_slice` 开头的 `const_reverse_iterator2`。
`const_reverse_iterator2 rend2 () const`	返回一个指向反向 `matrix_slice` 结尾的 `const_reverse_iterator2`。
`reverse_iterator2 rbegin2 ()`	返回一个指向反向 `matrix_slice` 开头的 `reverse_iterator2`。
`reverse_iterator2 rend2 ()`	返回一个指向反向 `matrix_slice` 结尾的 `reverse_iterator2`。

简单投影

描述

自由函数 subslice 支持矩阵切片的构造。

原型


    template<class M>
    matrix_slice<M> subslice (M &data,
       M::size_type start1, M::difference_type stride1, M::size_type size1,
       M::size_type start2, M::difference_type stride2, M::size_type size2);
    template<class M>
    const matrix_slice<const M> subslice (const M &data,
       M::size_type start1, M::difference_type stride1, M::size_type size1,
       M::size_type start2, M::difference_type stride2, M::size_type size2);

通用投影

描述

自由函数 project 支持矩阵切片的构造。现有的 matrix_slice 可以与进一步的范围或切片组合。结果切片使用现有切片的 compose 函数计算。

原型


    template<class M>
    matrix_slice<M> project (M &data, const slice &s1, const slice &s2);
    template<class M>
    const matrix_slice<const M> project (const M &data, const slice &s1, const slice &s2);
    template<class M>
    matrix_slice<M> project (matrix_slice<M> &data, const range &r1, const range &r2);
    template<class M>
    const matrix_slice<M> project (const matrix_slice<M> &data, const range &r1, const range &r2);
    template<class M>
    matrix_slice<M> project (matrix_slice<M> &data, const slice &s1, const slice &s2);
    template<class M>
    const matrix_slice<M> project (const matrix_slice<M> &data, const slice &s1, const slice &s2);

定义

定义于头文件 matrix_proxy.hpp 中。

类型要求

M 是矩阵表达式的模型。

复杂度

二次复杂度，取决于切片的大小。

示例

#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/matrix_proxy.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)
            project (m, slice (0, 1, 3), slice (0, 1, 3)) (i, j) = 3 * i + j;
    std::cout << project (m, slice (0, 1, 3), slice (0, 1, 3)) << std::endl;
}

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