Tutorialspoint.dev

std::gslice | Valarray generalized slice selector

Valarray generalized slice selector : This class represents a valarray generalized slice selector (a multidimensional slice). It does not contain nor refers to any element – it only describes a selection of elements to be used as an index in valarray::operator[].

In other words, 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 ij and a list of sizes dj, a std::gslice constructed from these values selects the set of indices :

kj = s + Σj(ijdj)

A valarray generalized slice is specified by a starting index, a set of sizes, and a set of strides. It produces a multidimensional combination of slice selections.

Syntax :



gslice( std::size_t start, const std::valarray& sizes,
                           const std::valarray& strides );
size_t start : index of the first element in the selection.
size_t (size) : number of elements in the selection.
size_t (stride) : span that separates the elements selected
  • In given Syntax, default constructor is Equivalent to gslice(0, std::valarray(), std::valarray()). This constructor exists only to allow construction of arrays of slices.
  • Constructs a new slice with parameters start, sizes, strides.

Example 1:

start = 1 , size = {2, 3} , stride = {7, 2}
Input :  0 1 2 3 4 5 6 7 8 9 10 11 12 13
Output : 1 3 5 8 10 12
Explanation: 1 + 0*7 + 0*2 = 1,
             1 + 0*7 + 1*2 = 3,
             1 + 0*7 + 2*2 = 5,
             1 + 1*7 + 0*2 = 8,
             1 + 1*7 + 1*2 = 10,
             1 + 1*7 + 2*2 = 12

Example 2:

start = 3 , size = {2,4,3} , strides = {19,4,1}
Input : 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
Output: 3 4 5 7 8 9 11 12 13 15 16 17 19 20 21 22
Explanation : 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 + 0*4 + 0*1 = 22 

Example 1 : gslice example in C++ Program :

// C++ Program to test the 
// functioning of std::gslice
#include <iostream>     // std::cout
#include <cstddef>      // std::size_t
#include <valarray>     // std::valarray, std::gslice
  
int main ()
{
  //valarray sample of size 14
  std::valarray<int> sample (14);
  for (int i=0; i<14; ++i) sample[i]=i;
  
  std::size_t start=1;
  std::size_t lengths[]= {2,3};
  std::size_t strides[]= {7,2};
    
  //gslice object which can be used directly
  std::gslice mygslice (start,
                        std::valarray<std::size_t>(lengths,2),
                        std::valarray<std::size_t>(strides,2));
  //creating data using gslice
  std::valarray<int> data = sample[mygslice];
  
 /* Can also be done in the following way 
 (without creating gslice object): 
 std::valarray<int> data=sample[std::gslice(start, 
                       std::valarray<std::size_t>(lengths,2),
                       std::valarray<std::size_t>(strides,2))];
  */  
  
  std::cout << "gslice:";
    
//displaying content of data 
  for (int i=0; i<data.size(); i++)
      std::cout << ' ' << data[i];
  std::cout << ' ';
  
  return 0;
}

Output:

gslice: 1 3 5 8 10 12

Example 2 : Demonstrates the use of gslices to address columns of a 3D array and performing some operations

//C++ Program to demonstrate use of 
// gslice to address columns of 3D array
#include <iostream> // std::cout
#include <valarray> // std::gslice
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 << ' ';
        }
        std::cout << ' ';
    }
}
int main()
{
    // 3d array: 2 x 4 x 3 elements
    std::valarray<int> v = 
    { 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: ";
    test_print(v, 2, 4, 3);
   
    // update every value in the first columns of both planes
    // two level one strides of 12 elements
    // then four level two strides of 3 elements
    v[std::gslice(0, {2, 4}, {4*3, 3})] = 1; 
     
   
    // 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: ";
    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 

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



This article is attributed to GeeksforGeeks.org

leave a comment

code

0 Comments

load comments

Subscribe to Our Newsletter