std::gslice

 

C++

Language

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

 

Numerics library

Common mathematical functions

Floating-point environment

Complex numbers

Numeric arrays

Pseudo-random number generation

Compile-time rational arithmetic (C++11)

Generic numeric operations

iota (C++11)

accumulate

inner_product

adjacent_difference

partial_sum

 

Numeric arrays

Member functions
valarray::valarray valarray::~valarray valarray::operator= valarray::operator[] valarray::swap valarray::size valarray::resize valarray::sum valarray::min valarray::max valarray::shift valarray::cshift valarray::apply	valarray::operator+ valarray::operator- valarray::operator~ valarray::operator! valarray::operator*= valarray::operator/= valarray::operator%= valarray::operator+= valarray::operator-= valarray::operator^= valarray::operator&= valarray::operator|= valarray::operator<<= valarray::operator>>=
Non-member functions
swap (C++11) begin (C++11) end (C++11) abs exp log log10 pow sqrt sin cos tan asin acos atan atan2 sinh cosh tanh	operator* operator/ operator% operator+ operator- operator^ operator& operator| operator<< operator>> operator&& operator operator== operator!= operator< operator> operator<= operator>=
Helper classes
slice_array gslice_array indirect_array	slice gslice mask_array

 

Defined in header <valarray>
class gslice;

std::gslice is the selector class that identifies a subset of std::valarray indices defined by a multi-level set of strides and sizes. Objects of type std::gslice can be used as indices with valarray's operator[] to select, for example, columns of a multidimensional array represented as a valarray.

Given the starting value s, a list of strides i
j and a list of sizes d
j, a std::gslice constructed from these values selects the set of indices k
j=s+Σ
j(i
jd
j).

For example, a gslice with starting index 3, strides {19,4,1} and lengths {2,4,3} generates the following set of indices: 3 + 0*19 + 0*4 + 0*1 = 3,
3 + 0*19 + 0*4 + 1*1 = 4,
3 + 0*19 + 0*4 + 2*1 = 5,
3 + 0*19 + 1*4 + 0*1 = 7,
3 + 0*19 + 1*4 + 1*1 = 8,
...
3 + 1*19 + 3*4 + 2*1 = 36

It is possible to construct std::gslice objects that select some indices more than once: if the above example used the strides {1,1,1} , the indices would have been {3, 4, 5, 4, 5, 6, ...} . Such gslices may only be used as arguments to the const version of std::valarray::operator[], otherwise the behavior is undefined.

Member functions

(constructor)	constructs a gslice (public member function)
start	accesses the start of the gslice (public member function)
stride	accesses the array of strides of the gslice (public member function)
size	accesses the array of sizees of the gslice (public member function)

Example

demonstrates the use of gslices to address columns of a 3D array

#include <iostream>
#include <valarray>
void test_print(std::valarray<int>& v, int rows, int cols, int planes)
{
    for(int r=0; r<rows; ++r) {
        for(int c=0; c<cols; ++c) {
            for(int z=0; z<planes; ++z)
                std::cout << v[r*cols*planes + c*planes + z] << ' ';
            std::cout << '\n';
        }
        std::cout << '\n';
    }
}
int main()
{
    std::valarray<int> v = // 3d array: 2 x 4 x 3 elements
    { 111,112,113 , 121,122,123 , 131,132,133 , 141,142,143,
      211,212,213 , 221,222,223 , 231,232,233 , 241,242,243};
    // int ar3d[2][4][3]
    std::cout << "Initial 2x4x3 array:\n";
    test_print(v, 2, 4, 3);
 
    // update every value in the first columns of both planes
    v[std::gslice(0, {2, 4}, {4*3, 3})] = 1; // two level one strides of 12 elements
                                             // then four level two strides of 3 elements
 
    // subtract the third column from the second column in the 1st plane
    v[std::gslice(1, {1, 4}, {4*3, 3})] -= v[std::gslice(2, {1, 4}, {4*3, 3})];
 
    std::cout << "After column operations: \n";
    test_print(v, 2, 4, 3);
}

Output:

Initial 2x4x3 array:
111 112 113
121 122 123
131 132 133
141 142 143
 
211 212 213
221 222 223
231 232 233
241 242 243
 
After column operations:
1 -1 113
1 -1 123
1 -1 133
1 -1 143
 
1 212 213
1 222 223
1 232 233
1 242 243

See also

operator[]	get/set valarray element, slice, or mask (public member function)
slice	BLAS-like slice of a valarray: starting index, length, stride (class)
gslice_array	proxy to a subset of a valarray after applying a gslice (class template)