如何旋转向量的向量

Question

我正在寻找一种优雅的方法来旋转向量的向量，最好使用STL算法或boost 示例数据看起来像这样

vector<vector<int> > vm;
vector<int> v;
v.push_back(1);
v.push_back(2);
vm.push_back(v);
v.clear();
v.push_back(3);
v.push_back(4);
vm.push_back(v);
v.clear();
v.push_back(5);
v.push_back(6);
vm.push_back(v);

1   2
3   4
5   6

我想获得像这样的整数向量的向量

1   3   5
2   4   6

Answer 1

我想最简单的解决方案就是编写一个简单的转置函数，其中包含两个循环：

std::vector<std::vector<int> > transpose(const std::vector<std::vector<int> > data) {
    // this assumes that all inner vectors have the same size and
    // allocates space for the complete result in advance
    std::vector<std::vector<int> > result(data[0].size(),
                                          std::vector<int>(data.size()));
    for (std::vector<int>::size_type i = 0; i < data[0].size(); i++) 
        for (std::vector<int>::size_type j = 0; j < data.size(); j++) {
            result[i][j] = data[j][i];
        }
    return result;
}

按值返回应该很容易被优化掉。我不认为使用任何标准函数会变得更简单或更有效，但我可能是错的。

另一种方法是将所有数据存储在一个平面向量中，然后使用i*row_length + j计算元素i, j的位置> 或类似的东西。这样，转置不涉及数据复制，而只是改变索引的计算。

Answer 2

看看 Boost MultiArray。您可以创建子视图您的数据。还有 vnl_matrix 具有转置方法。

Answer 3

我将介绍一个转换行 -> 的包装器山口和山口 ->排。这将避免您复制所有数据。

#include <iostream>
#include <vector>

template<typename T>
class TwoDPivotWrapper
{
    public:
        // These two typedef's were done with std::vector
        // in mind. But with a small amount of effort I am
        // sure they can be generalized. They are solely to define
        // value_type (the data stored in the 2-D array).
        typedef typename T::value_type          OneDType;
        typedef typename OneDType::value_type   value_type;

        // A constructor that wraps a 2-D structure.
        TwoDPivotWrapper(T& o)
            : object(o)
        {}

        // A helper class used to store the row after the first array accesses.
        class Row
        {
            friend class TwoDPivotWrapper;
            Row(TwoDPivotWrapper& w, size_t r)
                : wrapper(w)
                , row(r)
            {}

            TwoDPivotWrapper&    wrapper;  
            size_t               row;

            public:
                value_type operator[](size_t col)
                {                    
                    return wrapper.get(row,col);
                }
        };

        // The operator [] returns a Row object that overloads
        // the operator[] for the next dimension.
        Row operator[](size_t row)              {return Row(*this, row);}

        // Generic get function used to access elements.
        // Notice we swap the row/col around when accessing
        // the underlying object.
        value_type get(size_t row, size_t col)  {return object[col][row];}

    private:
        T&  object;
};

典型用法是：

int main()
{
    typedef std::vector<std::vector<int> >      TwoDVector;

    TwoDVector  data(3,std::vector<int>(2,0));

    data[0][0]  = 1; data[0][1]  = 2;
    data[1][0]  = 3; data[1][1]  = 4;
    data[2][0]  = 5; data[2][1]  = 6;

    TwoDPivotWrapper<TwoDVector>               wrapper(data);
    std::cout << wrapper[0][0] << wrapper[0][1] << wrapper[0][2] << "\n";
    std::cout << wrapper[1][0] << wrapper[1][1] << wrapper[1][2] << "\n";
}

Answer 4

如果您要使用 C++ 进行大量线性代数计算，您应该查看 Boost.uBlas。

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

template <class M>
void printMatrix(const M& m)
{
    for (size_t i=0; i<m.size1(); ++i)
    {
        for (size_t j=0; j<m.size2(); ++j)
            std::cout << m(i,j) << " ";
        std::cout << std::endl;
    }
}

int main()
{
    namespace ublas = boost::numeric::ublas;
    typedef ublas::matrix<double> Matrix;
    Matrix A(3, 2);

    // Fill matrix A with incrementing values
    double counter = 0.0;
    for (size_t i=0; i<A.size1(); ++i)
        for (size_t j=0; j<A.size2(); ++j)
            A(i,j) = ++counter;

    printMatrix(A);
    std::cout << std::endl;

    // Transpose A and store it in B
    Matrix B = ublas::trans(A);
    printMatrix(B);

    return 0;
}

Answer 5

它绝对必须是向量的向量吗？

如果没有，那么您可能可以在行*列元素的常规向量上实现包装器。

类似于：

class Vector
{
public:
    int operator[]( int index )
    {
        return 1;
    }
    friend class Wrapper;
private:
    Vector( std::vector<int> & vector, int index, int numElements );

    std::vector<int> v_;
    int index_;
    int numElements_;
};

class Wrapper
{
public:
    Vector operator[](int index)
    {
        return Vector( v_, index, numColumns_ );
    }

    Wrapper( int numRows, int numColumns);
    void setNumRows( int numRows );
    void setNumColumns( int numColumns );
private:
    std::vector<int> v_;
    int numRows_;
    int numColumns_;
};

并在 main 中：

Wrapper w;

int i = w[1][1];

编辑：

Vector 类将表示行或列数据。
它需要线性化矩阵、矩阵几何形状（行数和列数）以及它代表的行/列作为参数。

用铅笔和纸试试这个：
1. 将 3x4 矩阵的元素写成矩阵形式

11 12 13 14
21 22 23 24
31 32 33 34

1. 以线性化方式编写它们：

11 12 13 14 21 22 23 24 31 32 33 34

矩阵形式的元素索引与其线性化形式的索引之间存在简单的关系，该关系取决于矩阵的几何形状。

1. 如果您希望 Vector “包含”元素 21 22 23 24 （或 12 22 32），那么您需要在运算符 [] （int 索引）中实现一些逻辑，该逻辑将确定 Vector 中元素的基础向量中的索引[指数]。

假设您的 Vector 需要引用矩阵中的第二列（即 12 22 32）。
然后：
- 向量中的第一项（即 Vector[1]）是线性化矩阵中的第二个元素
- 向量中的第二项 22 是基础向量中的第 6 个元素
- 向量中的第三项 32 是 v_ 的第 10 个元素

现在，用铅笔和纸对矩阵的第三列（元素 13 23 33）执行相同的操作。
查看第二列的基础向量中的索引（分别为 2、6 和 10）与第三列的索引之间是否存在相似性。