Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::slice_array(3)	      C++ Standard Libary	   std::slice_array(3)

NAME
       std::slice_array	- std::slice_array

Synopsis
	  Defined in header <valarray>
	  template< class T > class slice_array;

	  std::slice_array is a	helper template	used by	the valarray subscript
       operator	with
	  std::slice  argument.	 It has	reference semantics to a subset	of the
       array specified
	  by the std::slice object.

Member types
	  Type	     Definition
	  value_type T

Member functions
	  constructor	constructs a slice_array
			(public	member function)
	  destructor	destroys a slice_array
			(public	member function)
	  operator=	assigns	contents
			(public	member function)
	  operator+=
	  operator-=
	  operator*=
	  operator/=
	  operator%=	performs arithmetic operation on the array referred by
       slice.
	  operator&=	(public	member function)
	  operator|=
	  operator^=
	  operator<<=
	  operator>>=

Example
       // Run this code

	#include <iostream>
	#include <valarray>

	class Matrix {
	    int	dim;
	    std::valarray<int> data;
	public:
	    explicit Matrix(int	dim, int init =	0)
		: dim{dim}, data(init, dim*dim)	{ }
	    void clear(int value = 0) {	data = value; }
	    void identity() { clear(); diagonal() = 1; }
	    int& operator()(int	x, int y) { return data[dim * y	+ x]; }

	    std::slice_array<int> diagonal() {
		return data[std::slice(0, dim, dim+1)];
	    }
	    std::slice_array<int> secondary_diagonal() {
		return data[std::slice(dim-1, dim, dim-1)];
	    }
	    std::slice_array<int> row(std::size_t row) {
		return data[std::slice(dim*row,	dim, 1)];
	    }
	    std::slice_array<int> column(std::size_t col) {
		return data[std::slice(col, dim, dim)];
	    }
	    template<unsigned, unsigned> friend	class MatrixStack;
	};

	template <unsigned dim = 3, unsigned max = 8> class MatrixStack	{
	    std::valarray<int> stack;
	    unsigned count = 0;
	public:
	    MatrixStack() : stack(dim*dim*max) {}
	    void print_all() const {
		std::valarray<int> row(dim*count);
		for (unsigned r	= 0; r != dim; ++r) { // screen	row
		    row	=  stack[std::gslice(r*dim,  {count,  dim},  {dim*dim,
       1})];
		    for	(unsigned i = 0; i != row.size(); ++i)
			std::cout << row[i] << ((i+1) %	dim ? "	" : "  ");
		    std::cout << '\n';
		}
	    }
	    void push_back(Matrix const& m) {
		if (count < max) {
		    stack[std::slice(count * dim * dim,	dim * dim, 1)]
			= m.data[std::slice(0, dim * dim, 1)];
		    ++count;
		}
	    }
	};

	int main()
	{
	    constexpr int dim =	3;
	    Matrix m{dim};
	    MatrixStack<dim,12>	stack;

	    m.identity();
	    stack.push_back(m);

	    m.clear(1);
	    m.secondary_diagonal() = 3;
	    stack.push_back(m);

	    for	(int i = 0; i != dim; ++i) {
		m.clear();
		m.row(i) = i + 1;
		stack.push_back(m);
	    }

	    for	(int i = 0; i != dim; ++i) {
		m.clear();
		m.column(i) = i	+ 1;
		stack.push_back(m);
	    }

	    m.clear();
	    m.row(1) = std::valarray<int>{4, 5,	6};
	    stack.push_back(m);

	    m.clear();
	    m.column(1)	= std::valarray<int>{7,	8, 9};
	    stack.push_back(m);

	    stack.print_all();
	}

Output:
	1 0 0  1 1 3  1	1 1  0 0 0  0 0	0  1 0 0  0 2 0	 0 0 3	0 0 0  0 7 0
	0 1 0  1 3 1  0	0 0  2 2 2  0 0	0  1 0 0  0 2 0	 0 0 3	4 5 6  0 8 0
	0 0 1  3 1 1  0	0 0  0 0 0  3 3	3  1 0 0  0 2 0	 0 0 3	0 0 0  0 9 0

See also
	  gslice_array proxy to	a subset of a valarray after applying a	gslice
		       (class template)

http://cppreference.com		  2022.07.31		   std::slice_array(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::slice_array&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help