How can I use a std::valarray to store/manipulate a contiguous 2D array?_问答_开发者

How can I use a std::valarray to store/manipulate a 2D array?

I'd like to see an example of a 2D array with elements accessed by row/column indices. Something like this pseudo code:

matrix(i,j) = 42;

An example of how to initialize such an array would also be nice.

I'm already aware of B开发者_Go百科oost.MultiArray, Boost.uBlas, and Blitz++.

Feel free to answer why I shouldn't use valarray for my use case. However, I want the memory for the multidimensional array to be a contiguous (columns x rows) block. No Java-style nested arrays.

Off the top of my head:

template <class element_type>
class matrix
{
public:
    matrix(size_t width, size_t height): m_stride(width), m_height(height), m_storage(width*height) {  }

    element_type &operator()(size_t row, size_t column)
    {
        // column major
        return m_storage[std::slice(column, m_height, m_stride)][row];

        // row major
        return m_storage[std::slice(row, m_stride, m_height)][column];
    }

private:
    std::valarray<element_type> m_storage;
    size_t m_stride;
    size_t m_height;
};

std::valarray provides many interesting ways to access elements, via slices, masks, multidimentional slices, or an indirection table. See std::slice_array, std::gslice_array, std::mask_array, and std::indirect_array for more details.

#include <iostream>
#include <valarray>

using namespace std;

typedef valarray<valarray<int> > va2d;

int main()
{
    int data[][3] = { {1, 2, 3}, {4, 5, 6} };
    va2d mat(valarray<int>(3), 2);
    for (int i = 0; i < 2; ++i)
    {
        for (int j = 0; j < 3; ++j)
           mat[ i ][ j ] = data[ i ][ j ];
    }
    for (int i = 0; i < 2; ++i)
        for (int j = 0; j < 3; ++j)
           cout << mat[ i ][ j ] << endl;
}

More on valarray:

It is optimized for numeric computation.
It is a vector like container with special member functions for slicing and dicing.
No iterators
Designed for vector machines and perform poorly on current ones: vector access may be faster
Was not supported by all compilers (check the documentation) / poorly implemented
See 26.1 for the types that can be used as a parameter to valarray<T>: E.g:

3 In addition, many member and related functions of valarray can be successfully instantiated and will exhibit well-defined behavior if and only if T satisfies additional requirements specified for each such member or related function.

4 [ Example: It is valid to instantiate valarray, but operator>() will not be successfully instantiated for valarray operands, since complex does not have any ordering operators. —end example ]

Edit#2: The standard gurantees that vector, like arrays, always use contiguous memory. Also, we have:

26.5.2 Class template valarray

1 The class template valarray is a one-dimensional smart array, with elements numbered sequentially from zero. It is a representation of the mathematical concept of an ordered set of values. The illusion of higher dimensionality may be produced by the familiar idiom of computed indices, together with the powerful subsetting capabilities provided by the generalized subscript operators.

and further:

26.5.2.3 valarray element access

4 Likewise, the expression &a[i] != &b[j] evaluates as true for any two arrays a and b and for any size_t i and size_t j such that i is less than the length of a and j is less than the length of b. This property indicates an absence of aliasing and may be used to advantage by optimizing compilers.

If you want to test for the multidimensional array to be a contiguous (columns x rows) block. You can see this example with valarray.

template<class T>
class Array: public std::valarray<T> {
  size_t row,col; 
public:
  Array(){}
  Array(size_t nx) : std::valarray<T>(nx){row=nx,col=1;}
  Array(size_t nx, size_t ny) : std::valarray<T>(nx*ny){row=nx,col=ny;}
  virtual ~Array(){}
  T& operator()(size_t i,size_t j) { return (*this)[i*col+j];}
  size_t Size(size_t n) const { return (n<2) ? col: row;}
};

Here's an example that includes a bit of matrix manipulation