标签: ublas

我已经实现了一个矩阵乘法boost::numeric::ublas::matrix(参见我的完整工作增强代码)

Result result = read ();

boost::numeric::ublas::matrix<int> C;
C = boost::numeric::ublas::prod(result.A, result.B);

另一个使用标准算法(参见完整的标准代码):

vector< vector<int> > ijkalgorithm(vector< vector<int> > A, 
                                    vector< vector<int> > B) {
    int n = A.size();

    // initialise C with 0s
    vector<int> tmp(n, 0);
    vector< vector<int> > C(n, tmp);

    for (int i = 0; i < n; i++) {
        for (int k = 0; k < n; k++) {
            for (int j = 0; j < n; j++) {
                C[i][j] += …

在boost::numeric::ublas,有三种稀疏矢量类型.

我可以看到它mapped_vector本质上是stl::map从索引到值,它将所有未找到的值视为0(或者是常见值).

但关于compressed_vector和的信息,文件很少(哈哈)coordinate_vector.

有人能够澄清吗？我试图弄清楚向各种向量添加项目的算法复杂性,以及两个这样的向量之间的点积.

一个非常有用的答案提供了compressed_vector与compressed_matrix非常相似.但似乎,例如,压缩行存储仅用于存储矩阵 - 而不仅仅是矢量.

我看到这unbounded_array是存储类型,但我也不太确定规范是什么.如果我创建一个大小为200,000,000但只有5个非零位置的compressed_vector,那么创建一个大小为10和非零位置的compressed_vector会不会有什么效率呢？

非常感谢!

我正在尝试实现某些矩阵操作,但我迷失在ublas库的内部.是否有一个资源,如教程或如何实现新的ublas矩阵表达式的例子？

谢谢

如何boost::numeric::ublas::vector和std::vector在运行时的效率比较？

是否可以安全地假设我可以通过编写将整个程序从使用转换std::vector为使用boost::numeric::ublas::vector:

#include <boost/numeric/ublas/vector.hpp>
using namespace boost::numeric::ublas;

而不是#include<vector>？我可以只使用增强矢量,就像它们在所有方面都是STL矢量一样吗？

做从功能<algorithm>有增强载体的工作？他们使用相同的迭代器吗？

它们在C++ 0x中工作吗？它们适用于基于范围的循环吗？

我是C++ Boost uBLAS库的新手,所以我有一个noob问题 - 如何使用这个库转置矩阵？我在这里找不到问题:

http://www.boost.org/doc/libs/1_44_0/libs/numeric/ublas/doc/html/index.html

在Eigen版本中,我使用"真正的"固定大小矩阵和向量,更好的算法(LDLT与uBlas的LU),它在内部使用SIMD指令.那么,为什么它在下面的例子中比uBlas慢？

我确信,我做错了 - Eigen 必须更快,或至少可比.

#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/lu.hpp>
#include <boost/numeric/ublas/symmetric.hpp>
#include <boost/progress.hpp>
#include <Eigen/Dense>
#include <iostream>

using namespace boost;
using namespace std;
const int n=9;
const int total=100000;

void test_ublas()
{
    using namespace boost::numeric::ublas;
    cout << "Boost.ublas ";
    double r=1.0;
    {
        boost::progress_timer t;
        for(int j=0;j!=total;++j)
        {
            //symmetric_matrix< double,lower,row_major,bounded_array<double,(1+n)*n/2> > A(n,n);
            matrix<double,row_major,bounded_array<double,n*n> > A(n,n);
            permutation_matrix< unsigned char,bounded_array<unsigned char,n> > P(n);
            bounded_vector<double,n> v;
            for(int i=0;i!=n;++i)
                for(int k=0;k!=n;++k)
                    A(i,k)=0.0;
            for(int i=0;i!=n;++i)
            {
                A(i,i)=1.0+i;
                v[i]=i;
            }
            lu_factorize(A,P);
            lu_substitute(A,P,v);
            r+=inner_prod(v,v);
        } …

我理解做类似以下的事情:

auto&& x = Matrix1() + Matrix2() + Matrix3();
std::cout << x(2,3) << std::endl;

如果矩阵运算使用表达式模板(例如boost::ublas),将导致静默运行时错误.

是否有任何设计表达式模板的方法来防止编译器编译可能导致在运行时使用过期临时值的代码？

(我尝试解决这个问题没有成功,尝试就在这里)

我有以下包含O(N)元素的稀疏矩阵

boost::numeric::ublas::compressed_matrix<int> adjacency (N, N);

我可以编写一个强力双循环来及时检查所有条目,O(N^2)如下所示,但这将太慢.

for(int i=0; i<N; ++i)
   for(int j=0; j<N; ++j)
       std::cout << adjacency(i,j) std::endl;

如何及时循环非零条目O(N)？对于每个非零元素,我希望能够访问其值和索引i,j.

我有一个方法,它将std :: vector作为其参数之一.有没有办法通过将std :: vector赋值给矩阵来初始化矩阵？这是我下面尝试做的.有谁知道如何实现将向量(甚至是双精度指针)分配给矩阵？提前致谢.麦克风

void Foo(std::vector v)
{
    matrix<double> m(m, n, v);
    // work with matrix...
}

我只是想从头到尾遍历矩阵,触及每个元素.但是,我看到没有一个迭代器用于boost矩阵,而是有两个迭代器,我无法弄清楚如何使它们工作以便你可以遍历整个矩阵

    typedef boost::numeric::ublas::matrix<float> matrix;

    matrix m1(3, 7);

    for (auto i = 0; i < m1.size1(); i++)
    {
        for (auto j = 0; j < m1.size2(); j++)
        {
            m1(i, j) = i + 1 + 0.1*j;
        }
    }

    for (auto itr1 = m1.begin1(); itr1!= m1.end1(); ++itr1)
    { 
        for (auto itr2 = m1.begin2(); itr2 != m1.end2(); itr2++)
        {
            //std::cout << *itr2  << " ";
            //std::cout << *itr1  << " ";
        }
    }

我的这个代码,使用itr1只打印矩阵的第1行,使用itr2只打印矩阵的第1列.可以做些什么来代替访问所有行和列？