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		  2024.06.10		   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.1.quarterly>

home | help