GenericMultiComponent4d.hpp

Go to the documentation of this file.

/*
 * Copyright(c):
 * Signal Image and Communications (SIC) Department 
 * http://www.sic.sp2mi.univ-poitiers.fr/ 
 *  - University of Poitiers, France http://www.univ-poitiers.fr 
 *  - XLIM  Institute UMR CNRS 7252  http://www.xlim.fr/ 
 * 
 * and 
 * 
 * D2 Fluid, Thermic and Combustion 
 *  - University of Poitiers, France http://www.univ-poitiers.fr 
 *  - PPRIME Institute -  UPR CNRS 3346  http://www.pprime.fr
 *  - ISAE-ENSMA http://www.ensma.fr
 *
 * Contributor(s):
 * The SLIP team,
 * Benoit Tremblais <tremblais_AT_sic.univ-poitiers.fr>,
 * Laurent David <laurent.david_AT_lea.univ-poitiers.fr>, 
 * Ludovic Chatellier <ludovic.chatellier_AT_univ-poitiers.fr>, 
 * Lionel Thomas <lionel.thomas_AT_univ-poitiers.fr>, 
 * Denis Arrivault <arrivault_AT_sic.univ-poitiers.fr>, 
 * Julien Dombre <julien.dombre_AT_univ-poitiers.fr>.
 *
 * Description:
 * The Simple Library of Image Processing (SLIP) is a new image processing 
 * library. It is written in the C++ language following as much as possible 
 * the ISO/ANSI C++ standard. It is consequently compatible with any system  
 * satisfying the ANSI C++ complience. It works on different Unix , Linux ,  
 * Mircrosoft Windows and Mac OS X plateforms. SLIP is a research library that  
 * was created by the Signal, Image and Communications (SIC) departement of  
 * the XLIM, UMR 7252 CNRS Institute in collaboration with the Fluids, Thermic  
 * and Combustion departement of the P', UPR 3346 CNRS Institute of the  
 * University of Poitiers.
 * 
 * The SLIP Library source code has been registered to the APP (French Agency 
 * for the Protection of Programs) by the University of Poitiers and CNRS, 
 * under  registration number IDDN.FR.001.300034.000.S.P.2010.000.21000.

 * http://www.sic.sp2mi.univ-poitiers.fr/slip/
 *
 * This software is governed by the CeCILL-C license under French law and
 * abiding by the rules of distribution of free software.  You can  use, 
 * modify and/ or redistribute the software under the terms of the CeCILL-C 
 * license as circulated by CEA, CNRS and INRIA at the following URL 
 * http://www.cecill.info.
 * As a counterpart to the access to the source code and  rights to copy,
 * modify and redistribute granted by the license, users are provided only
 * with a limited warranty  and the software's author,  the holder of the
 * economic rights,  and the successive licensors  have only  limited
 * liability.
 * 
 * In this respect, the user's attention is drawn to the risks associated
 * with loading,  using,  modifying and/or developing or reproducing the
 * software by the user in light of its specific status of free software,
 * that may mean  that it is complicated to manipulate,  and  that  also
 * therefore means  that it is reserved for developers  and  experienced
 * professionals having in-depth computer knowledge. Users are therefore
 * encouraged to load and test the software's suitability as regards their
 * requirements in conditions enabling the security of their systems and/or
 * data to be ensured and,  more generally, to use and operate it in the 
 * same conditions as regards security. 
 *
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL-C license and that you accept its terms.
 */

#ifndef SLIP_GENERICMULTICOMPONENT4D_HPP
#define SLIP_GENERICMULTICOMPONENT4D_HPP

#include <iostream>
#include <iterator>
#include <cassert>
#include <numeric>
#include <cmath>
#include <string>
#include <vector>
#include <cstddef>
#include "Matrix4d.hpp"
#include "Matrix.hpp"
#include "stride_iterator.hpp"
#include "kstride_iterator.hpp"
#include "apply.hpp"
#include "iterator4d_box.hpp"
#include "iterator4d_range.hpp"

#include "component_iterator4d_box.hpp"
#include "component_iterator4d_range.hpp"

#include <boost/serialization/access.hpp>
#include <boost/serialization/split_member.hpp>
#include <boost/serialization/version.hpp>

namespace slip
{

template<class Block>
class stride_iterator;

}//slip::

namespace slip
{

template <class Block>
class DPoint4d;

template <class Block>
class Point4d;

template <class Block>
class Box4d;

template <typename Block>
class GenericMultiComponent4d;

template <typename Block>
class Matrix4d;

template <class MultiComponentContainer4D, std::size_t N>
class component_iterator4d_box;

template <class MultiComponentContainer4d, std::size_t N>
class component_iterator4d_range;

template <typename Block>
std::ostream& operator<<(std::ostream & out, const GenericMultiComponent4d<Block>& a);

template<typename Block>
bool operator==(const GenericMultiComponent4d<Block>& x,
                                const GenericMultiComponent4d<Block>& y);

template<typename Block>
bool operator!=(const GenericMultiComponent4d<Block>& x,
                                const GenericMultiComponent4d<Block>& y);

// template<typename Block>
// bool operator<(const GenericMultiComponent4d<Block>& x,
//                     const GenericMultiComponent4d<Block>& y);

// template<typename Block>
// bool operator>(const GenericMultiComponent4d<Block>& x,
//                     const GenericMultiComponent4d<Block>& y);

// template<typename Block>
// bool operator<=(const GenericMultiComponent4d<Block>& x,
//                              const GenericMultiComponent4d<Block>& y);

// template<typename Block>
// bool operator>=(const GenericMultiComponent4d<Block>& x,
//                              const GenericMultiComponent4d<Block>& y);

template <typename Block>
class GenericMultiComponent4d
{
public :

                typedef Block value_type;
                typedef GenericMultiComponent4d<Block> self;
                typedef const GenericMultiComponent4d<Block> const_self;
                typedef value_type* pointer;
                typedef value_type const * const_pointer;
                typedef value_type& reference;
                typedef value_type const & const_reference;

                typedef ptrdiff_t difference_type;
                typedef std::size_t size_type;

                typedef pointer iterator;
                typedef const_pointer const_iterator;

                typedef std::reverse_iterator<iterator> reverse_iterator;
                typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

                //slab, slice, row and col iterators
                typedef slip::stride_iterator<pointer> slab_iterator;
                typedef slip::stride_iterator<const_pointer> const_slab_iterator;
                typedef slip::stride_iterator<pointer> slice_iterator;
                typedef slip::stride_iterator<const_pointer> const_slice_iterator;
                typedef pointer row_iterator;
                typedef const_pointer const_row_iterator;
                typedef slip::stride_iterator<pointer> col_iterator;
                typedef slip::stride_iterator<const_pointer> const_col_iterator;
                //slab, slice, row and col range iterators
                typedef slip::stride_iterator<slab_iterator> slab_range_iterator;
                typedef slip::stride_iterator<const_slab_iterator> const_slab_range_iterator;
                typedef slip::stride_iterator<slice_iterator> slice_range_iterator;
                typedef slip::stride_iterator<const_slice_iterator> const_slice_range_iterator;
                typedef slip::stride_iterator<pointer> row_range_iterator;
                typedef slip::stride_iterator<const_pointer> const_row_range_iterator;
                typedef slip::stride_iterator<col_iterator> col_range_iterator;
                typedef slip::stride_iterator<const_col_iterator> const_col_range_iterator;
                //slab, slice, row and col reverse iterators
                typedef std::reverse_iterator<slab_iterator> reverse_slab_iterator;
                typedef std::reverse_iterator<const_slab_iterator> const_reverse_slab_iterator;
                typedef std::reverse_iterator<slice_iterator> reverse_slice_iterator;
                typedef std::reverse_iterator<const_slice_iterator> const_reverse_slice_iterator;
                typedef std::reverse_iterator<iterator> reverse_row_iterator;
                typedef std::reverse_iterator<const_iterator> const_reverse_row_iterator;
                typedef std::reverse_iterator<col_iterator> reverse_col_iterator;
                typedef std::reverse_iterator<const_col_iterator> const_reverse_col_iterator;
                //slab, slice, row and col reverse range iterators
                typedef std::reverse_iterator<slab_range_iterator> reverse_slab_range_iterator;
                typedef std::reverse_iterator<const_slab_range_iterator> const_reverse_slab_range_iterator;
                typedef std::reverse_iterator<slice_range_iterator> reverse_slice_range_iterator;
                typedef std::reverse_iterator<const_slice_range_iterator> const_reverse_slice_range_iterator;
                typedef std::reverse_iterator<row_range_iterator> reverse_row_range_iterator;
                typedef std::reverse_iterator<const_row_range_iterator> const_reverse_row_range_iterator;
                typedef std::reverse_iterator<col_range_iterator> reverse_col_range_iterator;
                typedef std::reverse_iterator<const_col_range_iterator> const_reverse_col_range_iterator;

                //Component iterators
                typedef typename Block::value_type block_value_type;
                typedef block_value_type* block_pointer;
                typedef const block_value_type* const_block_pointer;
                typedef block_value_type& block_reference;
                typedef const block_value_type const_block_reference;
                typedef slip::kstride_iterator<typename Block::pointer,Block::SIZE> component_iterator;
                typedef slip::kstride_iterator<typename Block::const_pointer,Block::SIZE> const_component_iterator;
                //Component reverse iterators
                typedef std::reverse_iterator<component_iterator> reverse_component_iterator;
                typedef std::reverse_iterator<const_component_iterator> const_reverse_component_iterator;

                //component slab, slice, row and col iterator
                typedef slip::stride_iterator<block_pointer> component_slab_iterator;
                typedef slip::stride_iterator<const_block_pointer> const_component_slab_iterator;
                typedef slip::stride_iterator<block_pointer> component_slice_iterator;
                typedef slip::stride_iterator<const_block_pointer> const_component_slice_iterator;
                typedef component_iterator component_row_iterator;
                typedef const_component_iterator const_component_row_iterator;
                typedef slip::stride_iterator<block_pointer> component_col_iterator;
                typedef slip::stride_iterator<const_block_pointer> const_component_col_iterator;
                //component slab, slice, row and col range iterator
                typedef slip::stride_iterator<block_pointer> component_slab_range_iterator;
                typedef slip::stride_iterator<const_block_pointer> const_component_slab_range_iterator;
                typedef slip::stride_iterator<block_pointer> component_slice_range_iterator;
                typedef slip::stride_iterator<const_block_pointer> const_component_slice_range_iterator;
                typedef slip::stride_iterator<block_pointer> component_row_range_iterator;
                typedef slip::stride_iterator<const_block_pointer> const_component_row_range_iterator;
                typedef slip::stride_iterator<block_pointer> component_col_range_iterator;
                typedef slip::stride_iterator<const_block_pointer> const_component_col_range_iterator;
                //component slab, slice, row and col reverse iterator
                typedef std::reverse_iterator<component_slab_iterator> reverse_component_slab_iterator;
                typedef std::reverse_iterator<const_component_slab_iterator> const_reverse_component_slab_iterator;
                typedef std::reverse_iterator<component_slice_iterator> reverse_component_slice_iterator;
                typedef std::reverse_iterator<const_component_slice_iterator> const_reverse_component_slice_iterator;
                typedef std::reverse_iterator<component_row_iterator> reverse_component_row_iterator;
                typedef std::reverse_iterator<const_component_row_iterator> const_reverse_component_row_iterator;
                typedef std::reverse_iterator<component_col_iterator> reverse_component_col_iterator;
                typedef std::reverse_iterator<const_component_col_iterator> const_reverse_component_col_iterator;
                //component slab, slice, row and col reverse range iterator
                typedef std::reverse_iterator<component_slab_range_iterator> reverse_component_slab_range_iterator;
                typedef std::reverse_iterator<const_component_slab_range_iterator> const_reverse_component_slab_range_iterator;
                typedef std::reverse_iterator<component_slice_range_iterator> reverse_component_slice_range_iterator;
                typedef std::reverse_iterator<const_component_slice_range_iterator> const_reverse_component_slice_range_iterator;
                typedef std::reverse_iterator<component_row_range_iterator> reverse_component_row_range_iterator;
                typedef std::reverse_iterator<const_component_row_range_iterator> const_reverse_component_row_range_iterator;
                typedef std::reverse_iterator<component_col_range_iterator> reverse_component_col_range_iterator;
                typedef std::reverse_iterator<const_component_col_range_iterator> const_reverse_component_col_range_iterator;

                //iterator 4d
                typedef typename Array4d<Block>::iterator4d iterator4d;
                typedef typename Array4d<Block>::const_iterator4d const_iterator4d;
                typedef typename Array4d<Block>::iterator4d_range iterator4d_range;
                typedef typename Array4d<Block>::const_iterator4d_range const_iterator4d_range;
                //iterator reverse 4d
                typedef std::reverse_iterator<iterator4d> reverse_iterator4d;
                typedef std::reverse_iterator<const_iterator4d> const_reverse_iterator4d;
                typedef std::reverse_iterator<iterator4d_range> reverse_iterator4d_range;
                typedef std::reverse_iterator<const_iterator4d_range> const_reverse_iterator4d_range;


                //component iterator 4d
                typedef component_iterator4d_box<self,Block::SIZE> component_iterator4d;
                typedef const_component_iterator4d_box<const_self,Block::SIZE> const_component_iterator4d;
                typedef slip::component_iterator4d_range<self,Block::SIZE> component_iterator4d_range;
                typedef slip::const_component_iterator4d_range<const_self,Block::SIZE> const_component_iterator4d_range;
                //component reverse iterator 4d
                typedef std::reverse_iterator<component_iterator4d> reverse_component_iterator4d;
                typedef std::reverse_iterator<const_component_iterator4d> const_reverse_component_iterator4d;
                typedef std::reverse_iterator<component_iterator4d_range> reverse_component_iterator4d_range;
                typedef std::reverse_iterator<const_component_iterator4d_range> const_reverse_component_iterator4d_range;


                //default iterator of the container
                typedef iterator4d default_iterator;
                typedef const_iterator4d const_default_iterator;


                static const std::size_t DIM = 4;
                static const std::size_t COMPONENTS = Block::SIZE;

public:

                GenericMultiComponent4d();

                GenericMultiComponent4d(const size_type slabs, const size_type slices,
                                                const size_type rows,
                                                const size_type cols);

                GenericMultiComponent4d(const size_type slabs, const size_type slices,
                                                const size_type rows,
                                                const size_type cols,
                                                const Block& val);

                GenericMultiComponent4d(const size_type slabs, const size_type slices,
                                                const size_type rows,
                                                const size_type cols,
                                                typename Block::const_pointer val);

                GenericMultiComponent4d(const size_type slabs, const size_type slices,
                                                const size_type rows,
                                                const size_type cols,
                                                const Block* val);


                template<typename InputIterator>
                GenericMultiComponent4d(const size_type slabs, const size_type slices,
                                                const size_type rows,
                                                const size_type cols,
                                                InputIterator first,
                                                InputIterator last)
                                                {
                                matrix_ = new Matrix4d<Block>(slabs,slices,rows,cols,first,last);
                                                }

                template<typename InputIterator>
                GenericMultiComponent4d(const size_type slabs, const size_type slices,
                                                const size_type rows,
                                                const size_type cols,
                                                std::vector<InputIterator> first_iterators_list,
                                                InputIterator last)

                                                {
                                matrix_ = new Matrix4d<Block>(slabs,slices,rows,cols);
                                this->fill(first_iterators_list,last);
                                                }


                GenericMultiComponent4d(const self& rhs);

                virtual ~GenericMultiComponent4d();


                void resize(const size_type slabs,
                                                const size_type slices,
                                                const size_type rows,
                                                const size_type cols,
                                                const Block& val = Block());


                //****************************************************************************
                //                          One dimensional iterators
                //****************************************************************************



                //----------------------Global iterators------------------------------

                iterator begin();

                const_iterator begin() const;

                iterator end();

                const_iterator end() const;

                reverse_iterator rbegin();

                const_reverse_iterator rbegin() const;

                reverse_iterator rend();

                const_reverse_iterator rend() const;

                //--------------------One dimensional slab iterators----------------------

                slab_iterator slab_begin(const size_type slice, const size_type row, const size_type col);

                const_slab_iterator slab_begin(const size_type slice, const size_type row, const size_type col) const;

                slab_iterator slab_end(const size_type slice, const size_type row, const size_type col);

                const_slab_iterator slab_end(const size_type slice, const size_type row, const size_type col) const;


                reverse_slab_iterator slab_rbegin(const size_type slice, const size_type row, const size_type col);

                const_reverse_slab_iterator slab_rbegin(const size_type slice, const size_type row, const size_type col) const;

                reverse_slab_iterator slab_rend(const size_type slice, const size_type row, const size_type col);


                const_reverse_slab_iterator slab_rend(const size_type slice, const size_type row, const size_type col) const;

                //--------------------One dimensional slice iterators----------------------

                slice_iterator slice_begin(const size_type slab, const size_type row, const size_type col);

                const_slice_iterator slice_begin(const size_type slab, const size_type row, const size_type col) const;

                slice_iterator slice_end(const size_type slab, const size_type row, const size_type col);

                const_slice_iterator slice_end(const size_type slab, const size_type row, const size_type col) const;


                reverse_slice_iterator slice_rbegin(const size_type slab, const size_type row, const size_type col);

                const_reverse_slice_iterator slice_rbegin(const size_type slab, const size_type row, const size_type col) const;

                reverse_slice_iterator slice_rend(const size_type slab, const size_type row, const size_type col);


                const_reverse_slice_iterator slice_rend(const size_type slab,
                                                const size_type row, const size_type col) const;

                //-------------------row iterators----------

                row_iterator row_begin(const size_type slab, const size_type slice,
                                                const size_type row);

                const_row_iterator row_begin(const size_type slab, const size_type slice,
                                                const size_type row) const;


                row_iterator row_end(const size_type slab, const size_type slice,
                                                const size_type row);


                const_row_iterator row_end(const size_type slab, const size_type slice,
                                                const size_type row) const;


                reverse_row_iterator row_rbegin(const size_type slab, const size_type slice,
                                                const size_type row);

                const_reverse_row_iterator row_rbegin(const size_type slab, const size_type slice,
                                                const size_type row) const;


                reverse_row_iterator row_rend(const size_type slab, const size_type slice,
                                                const size_type row);


                const_reverse_row_iterator row_rend(const size_type slab, const size_type slice,
                                                const size_type row) const;


                //-------------------Constant col iterators----------

                col_iterator col_begin(const size_type slab, const size_type slice,
                                                const size_type col);


                const_col_iterator col_begin(const size_type slab, const size_type slice,
                                                const size_type col) const;

                col_iterator col_end(const size_type slab, const size_type slice,
                                                const size_type col);


                const_col_iterator col_end(const size_type slab, const size_type slice,
                                                const size_type col) const;


                reverse_col_iterator col_rbegin(const size_type slab, const size_type slice,
                                                const size_type col);


                const_reverse_col_iterator col_rbegin(const size_type slab, const size_type slice,
                                                const size_type col) const;

                reverse_col_iterator col_rend(const size_type slab, const size_type slice,
                                                const size_type col);


                const_reverse_col_iterator col_rend(const size_type slab, const size_type slice,
                                                const size_type col) const;


                //------------------------slab range iterators -----------------------

                slab_range_iterator slab_begin(const size_type slice, const size_type row,const size_type col,
                                                const slip::Range<int>& range);


                slab_range_iterator slab_end(const size_type slice, const size_type row,const size_type col,
                                                const slip::Range<int>& range);


                const_slab_range_iterator slab_begin(const size_type slice, const size_type row,const size_type col,
                                                const slip::Range<int>& range) const;

                const_slab_range_iterator slab_end(const size_type slice, const size_type row,const size_type col,
                                                const slip::Range<int>& range) const;


                reverse_slab_range_iterator slab_rbegin(const size_type slice, const size_type row,const size_type col,
                                                const slip::Range<int>& range);


                reverse_slab_range_iterator slab_rend(const size_type slice, const size_type row,const size_type col,
                                                const slip::Range<int>& range);


                const_reverse_slab_range_iterator slab_rbegin(const size_type slice, const size_type row,const size_type col,
                                                const slip::Range<int>& range) const;

                const_reverse_slab_range_iterator slab_rend(const size_type slice, const size_type row,const size_type col,
                                                const slip::Range<int>& range) const;


                //------------------------slice range iterators -----------------------

                slice_range_iterator slice_begin(const size_type slab, const size_type row, const size_type col,
                                                const slip::Range<int>& range);


                slice_range_iterator slice_end(const size_type slab, const size_type row, const size_type col,
                                                const slip::Range<int>& range);


                const_slice_range_iterator slice_begin(const size_type slab, const size_type row, const size_type col,
                                                const slip::Range<int>& range) const;

                const_slice_range_iterator slice_end(const size_type slab, const size_type row, const size_type col,
                                                const slip::Range<int>& range) const;


                reverse_slice_range_iterator slice_rbegin(const size_type slab, const size_type row, const size_type col,
                                                const slip::Range<int>& range);


                reverse_slice_range_iterator slice_rend(const size_type slab, const size_type row, const size_type col,
                                                const slip::Range<int>& range);


                const_reverse_slice_range_iterator slice_rbegin(const size_type slab, const size_type row, const size_type col,
                                                const slip::Range<int>& range) const;

                const_reverse_slice_range_iterator slice_rend(const size_type slab, const size_type row, const size_type col,
                                                const slip::Range<int>& range) const;


                //------------------------row range iterators -----------------------

                row_range_iterator row_begin(const size_type slab, const size_type slice, const size_type row,
                                                const slip::Range<int>& range);

                row_range_iterator row_end(const size_type slab, const size_type slice, const size_type row,
                                                const slip::Range<int>& range);


                const_row_range_iterator row_begin(const size_type slab, const size_type slice, const size_type row,
                                                const slip::Range<int>& range) const;


                const_row_range_iterator row_end(const size_type slab, const size_type slice, const size_type row,
                                                const slip::Range<int>& range) const;

                reverse_row_range_iterator row_rbegin(const size_type slab, const size_type slice, const size_type row,
                                                const slip::Range<int>& range);


                reverse_row_range_iterator row_rend(const size_type slab, const size_type slice, const size_type row,
                                                const slip::Range<int>& range);



                const_reverse_row_range_iterator row_rbegin(const size_type slab, const size_type slice, const size_type row,
                                                const slip::Range<int>& range) const;


                const_reverse_row_range_iterator row_rend(const size_type slab, const size_type slice, const size_type row,
                                                const slip::Range<int>& range) const;

                //------------------------col range iterators -----------------------


                col_range_iterator col_begin(const size_type slab, const size_type slice, const size_type col,
                                                const slip::Range<int>& range);

                col_range_iterator col_end(const size_type slab, const size_type slice, const size_type col,
                                                const slip::Range<int>& range);


                const_col_range_iterator col_begin(const size_type slab, const size_type slice, const size_type col,
                                                const slip::Range<int>& range) const;


                const_col_range_iterator col_end(const size_type slab, const size_type slice, const size_type col,
                                                const slip::Range<int>& range) const;

                reverse_col_range_iterator col_rbegin(const size_type slab, const size_type slice,
                                                const size_type col, const slip::Range<int>& range);

                reverse_col_range_iterator col_rend(const size_type slab, const size_type slice,
                                                const size_type col, const slip::Range<int>& range);

                const_reverse_col_range_iterator col_rbegin(const size_type slab, const size_type slice,
                                                const size_type col, const slip::Range<int>& range) const;

                const_reverse_col_range_iterator col_rend(const size_type slab, const size_type slice,
                                                const size_type col, const slip::Range<int>& range) const;

                //****************************************************************************
                //                          Four dimensional iterators
                //****************************************************************************


                //------------------------ Global iterators------------------------------------

                iterator4d first_front_upper_left();


                iterator4d last_back_bottom_right();


                const_iterator4d first_front_upper_left() const;


                const_iterator4d last_back_bottom_right() const;

                reverse_iterator4d rfirst_front_upper_left();

                reverse_iterator4d rlast_back_bottom_right();

                const_reverse_iterator4d rfirst_front_upper_left() const;


                const_reverse_iterator4d rlast_back_bottom_right() const;


                //------------------------ Box iterators------------------------------------

                iterator4d first_front_upper_left(const Box4d<int>& box);


                iterator4d last_back_bottom_right(const Box4d<int>& box);


                const_iterator4d first_front_upper_left(const Box4d<int>& box) const;


                const_iterator4d last_back_bottom_right(const Box4d<int>& box) const;



                reverse_iterator4d rfirst_front_upper_left(const Box4d<int>& box);

                reverse_iterator4d rlast_back_bottom_right(const Box4d<int>& box);

                const_reverse_iterator4d rfirst_front_upper_left(const Box4d<int>& box) const;


                const_reverse_iterator4d rlast_back_bottom_right(const Box4d<int>& box) const;



                //------------------------ Range iterators------------------------------------

                iterator4d_range first_front_upper_left(const slip::Range<int>& slab_range,
                                                const slip::Range<int>& slice_range, const slip::Range<int>& row_range,
                                                const slip::Range<int>& col_range);

                iterator4d_range last_back_bottom_right(const slip::Range<int>& slab_range,
                                                const slip::Range<int>& slice_range, const slip::Range<int>& row_range,
                                                const slip::Range<int>& col_range);

                const_iterator4d_range first_front_upper_left(const slip::Range<int>& slab_range,
                                                const slip::Range<int>& slice_range, const slip::Range<int>& row_range,
                                                const slip::Range<int>& col_range) const;


                const_iterator4d_range last_back_bottom_right(const slip::Range<int>& slab_range,
                                                const slip::Range<int>& slice_range, const slip::Range<int>& row_range,
                                                const slip::Range<int>& col_range) const;

                reverse_iterator4d_range rfirst_front_upper_left(const slip::Range<int>& slab_range,
                                                const slip::Range<int>& slice_range, const slip::Range<int>& row_range,
                                                const slip::Range<int>& col_range);

                reverse_iterator4d_range rlast_back_bottom_right(const slip::Range<int>& slab_range,
                                                const slip::Range<int>& slice_range, const slip::Range<int>& row_range,
                                                const slip::Range<int>& col_range);

                const_reverse_iterator4d_range rfirst_front_upper_left(const slip::Range<int>& slab_range,
                                                const slip::Range<int>& slice_range, const slip::Range<int>& row_range,
                                                const slip::Range<int>& col_range) const;

                const_reverse_iterator4d_range rlast_back_bottom_right(const slip::Range<int>& slab_range,
                                                const slip::Range<int>& slice_range, const slip::Range<int>& row_range,
                                                const slip::Range<int>& col_range) const;


                //**************************************************************************************************************
                //**************************************************************************************************************
                //************************                   Component iterator              ***********************************
                //**************************************************************************************************************
                //**************************************************************************************************************


                //------------------------ Component iterators------------------------------------

                component_iterator begin(const std::size_t component);

                const_component_iterator begin(const std::size_t component) const;

                component_iterator end(const std::size_t component);

                const_component_iterator end(const std::size_t component) const;

                reverse_component_iterator rbegin(const std::size_t component);

                const_reverse_component_iterator rbegin(const std::size_t component) const;

                reverse_component_iterator rend(const std::size_t component);

                const_reverse_component_iterator rend(const std::size_t component) const;



                //--------------------One dimensional component slab iterators----------------------

                component_slab_iterator slab_begin(const std::size_t component, const size_type slice,
                                                const size_type row, const size_type col);

                const_component_slab_iterator slab_begin(const std::size_t component, const size_type slice,
                                                const size_type row, const size_type col) const;

                component_slab_iterator slab_end(const std::size_t component, const size_type slice,
                                                const size_type row, const size_type col);

                const_component_slab_iterator slab_end(const std::size_t component, const size_type slice,
                                                const size_type row, const size_type col) const;


                reverse_component_slab_iterator slab_rbegin(const std::size_t component, const size_type slice,
                                                const size_type row, const size_type col);

                const_reverse_component_slab_iterator slab_rbegin(const std::size_t component, const size_type slice,
                                                const size_type row, const size_type col) const;

                reverse_component_slab_iterator slab_rend(const std::size_t component, const size_type slice,
                                                const size_type row, const size_type col);


                const_reverse_component_slab_iterator slab_rend(const std::size_t component, const size_type slice,
                                                const size_type row, const size_type col) const;

                //--------------------One dimensional component slice iterators----------------------

                component_slice_iterator slice_begin(const std::size_t component, const size_type slab,
                                                const size_type row, const size_type col);

                const_component_slice_iterator slice_begin(const std::size_t component, const size_type slab,
                                                const size_type row, const size_type col) const;

                component_slice_iterator slice_end(const std::size_t component, const size_type slab,
                                                const size_type row, const size_type col);

                const_component_slice_iterator slice_end(const std::size_t component, const size_type slab,
                                                const size_type row, const size_type col) const;


                reverse_component_slice_iterator slice_rbegin(const std::size_t component, const size_type slab,
                                                const size_type row, const size_type col);

                const_reverse_component_slice_iterator slice_rbegin(const std::size_t component, const size_type slab,
                                                const size_type row, const size_type col) const;

                reverse_component_slice_iterator slice_rend(const std::size_t component, const size_type slab,
                                                const size_type row, const size_type col);


                const_reverse_component_slice_iterator slice_rend(const std::size_t component, const size_type slab,
                                                const size_type row, const size_type col) const;

                //-------------------row component iterators----------

                component_row_iterator row_begin(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type row);

                const_component_row_iterator row_begin(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type row) const;


                component_row_iterator row_end(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type row);


                const_component_row_iterator row_end(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type row) const;


                reverse_component_row_iterator row_rbegin(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type row);

                const_reverse_component_row_iterator row_rbegin(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type row) const;


                reverse_component_row_iterator row_rend(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type row);


                const_reverse_component_row_iterator row_rend(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type row) const;


                //-------------------Constant component col iterators----------

                component_col_iterator col_begin(const std::size_t component, const size_type slab,
                                                const size_type slice,          const size_type col);


                const_component_col_iterator col_begin(const std::size_t component, const size_type slab,
                                                const size_type slice,          const size_type col) const;

                component_col_iterator col_end(const std::size_t component, const size_type slab,
                                                const size_type slice,          const size_type col);


                const_component_col_iterator col_end(const std::size_t component, const size_type slab,
                                                const size_type slice,          const size_type col) const;


                reverse_component_col_iterator col_rbegin(const std::size_t component, const size_type slab,
                                                const size_type slice,          const size_type col);


                const_reverse_component_col_iterator col_rbegin(const std::size_t component, const size_type slab,
                                                const size_type slice,          const size_type col) const;

                reverse_component_col_iterator col_rend(const std::size_t component, const size_type slab,
                                                const size_type slice,          const size_type col);


                const_reverse_component_col_iterator col_rend(const std::size_t component, const size_type slab,
                                                const size_type slice,          const size_type col) const;


                //------------------------component slab range iterators -----------------------

                component_slab_range_iterator slab_begin(const std::size_t component, const size_type slice,
                                                const size_type row, const size_type col, const slip::Range<int>& range);


                component_slab_range_iterator slab_end(const std::size_t component, const size_type slice,
                                                const size_type row, const size_type col, const slip::Range<int>& range);


                const_component_slab_range_iterator slab_begin(const std::size_t component, const size_type slice,
                                                const size_type row, const size_type col, const slip::Range<int>& range) const;

                const_component_slab_range_iterator slab_end(const std::size_t component, const size_type slice,
                                                const size_type row, const size_type col, const slip::Range<int>& range) const;


                reverse_component_slab_range_iterator slab_rbegin(const std::size_t component, const size_type slice,
                                                const size_type row, const size_type col, const slip::Range<int>& range);


                reverse_component_slab_range_iterator slab_rend(const std::size_t component, const size_type slice,
                                                const size_type row, const size_type col, const slip::Range<int>& range);


                const_reverse_component_slab_range_iterator slab_rbegin(const std::size_t component, const size_type slice,
                                                const size_type row, const size_type col, const slip::Range<int>& range) const;

                const_reverse_component_slab_range_iterator slab_rend(const std::size_t component, const size_type slice,
                                                const size_type row, const size_type col, const slip::Range<int>& range) const;


                //------------------------component slice range iterators -----------------------

                component_slice_range_iterator slice_begin(const std::size_t component, const size_type slab,
                                                const size_type row, const size_type col, const slip::Range<int>& range);


                component_slice_range_iterator slice_end(const std::size_t component, const size_type slab,
                                                const size_type row, const size_type col, const slip::Range<int>& range);


                const_component_slice_range_iterator slice_begin(const std::size_t component, const size_type slab,
                                                const size_type row, const size_type col, const slip::Range<int>& range) const;

                const_component_slice_range_iterator slice_end(const std::size_t component, const size_type slab,
                                                const size_type row, const size_type col, const slip::Range<int>& range) const;


                reverse_component_slice_range_iterator slice_rbegin(const std::size_t component, const size_type slab,
                                                const size_type row, const size_type col, const slip::Range<int>& range);


                reverse_component_slice_range_iterator slice_rend(const std::size_t component, const size_type slab,
                                                const size_type row, const size_type col, const slip::Range<int>& range);


                const_reverse_component_slice_range_iterator slice_rbegin(const std::size_t component, const size_type slab,
                                                const size_type row, const size_type col, const slip::Range<int>& range) const;

                const_reverse_component_slice_range_iterator slice_rend(const std::size_t component, const size_type slab,
                                                const size_type row, const size_type col, const slip::Range<int>& range) const;


                //------------------------component row range iterators -----------------------

                component_row_range_iterator row_begin(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type row, const slip::Range<int>& range);

                component_row_range_iterator row_end(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type row, const slip::Range<int>& range);


                const_component_row_range_iterator row_begin(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type row, const slip::Range<int>& range) const;


                const_component_row_range_iterator row_end(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type row, const slip::Range<int>& range) const;

                reverse_component_row_range_iterator row_rbegin(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type row, const slip::Range<int>& range);

                reverse_component_row_range_iterator row_rend(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type row, const slip::Range<int>& range);

                const_reverse_component_row_range_iterator row_rbegin(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type row, const slip::Range<int>& range) const;


                const_reverse_component_row_range_iterator row_rend(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type row, const slip::Range<int>& range) const;

                //------------------------component col range iterators -----------------------


                component_col_range_iterator col_begin(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type col, const slip::Range<int>& range);

                component_col_range_iterator col_end(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type col, const slip::Range<int>& range);


                const_component_col_range_iterator col_begin(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type col, const slip::Range<int>& range) const;


                const_component_col_range_iterator col_end(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type col, const slip::Range<int>& range) const;

                reverse_component_col_range_iterator col_rbegin(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type col, const slip::Range<int>& range);

                reverse_component_col_range_iterator col_rend(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type col, const slip::Range<int>& range);

                const_reverse_component_col_range_iterator col_rbegin(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type col, const slip::Range<int>& range) const;

                const_reverse_component_col_range_iterator col_rend(const std::size_t component, const size_type slab,
                                                const size_type slice, const size_type col, const slip::Range<int>& range) const;

                //****************************************************************************
                //                          four dimensional component iterators
                //****************************************************************************


                //------------------------ Global component iterators------------------------------------

                component_iterator4d first_front_upper_left(const std::size_t component);

                component_iterator4d last_back_bottom_right(const std::size_t component);

                const_component_iterator4d first_front_upper_left(const std::size_t component) const;

                const_component_iterator4d last_back_bottom_right(const std::size_t component) const;

                reverse_component_iterator4d rfirst_front_upper_left(const std::size_t component);

                reverse_component_iterator4d rlast_back_bottom_right(const std::size_t component);

                const_reverse_component_iterator4d rfirst_front_upper_left(const std::size_t component) const;


                const_reverse_component_iterator4d rlast_back_bottom_right(const std::size_t component) const;

                //------------------------ Box component iterators------------------------------------

                component_iterator4d first_front_upper_left(const std::size_t component,
                                                const Box4d<int>& box);

                component_iterator4d last_back_bottom_right(const std::size_t component,
                                                const Box4d<int>& box);

                const_component_iterator4d first_front_upper_left(const std::size_t component,
                                                const Box4d<int>& box) const;

                const_component_iterator4d last_back_bottom_right(const std::size_t component,
                                                const Box4d<int>& box) const;

                reverse_component_iterator4d rfirst_front_upper_left(const std::size_t component,
                                                const Box4d<int>& box);

                reverse_component_iterator4d rlast_back_bottom_right(const std::size_t component,
                                                const Box4d<int>& box);

                const_reverse_component_iterator4d rfirst_front_upper_left(const std::size_t component,
                                                const Box4d<int>& box) const;


                const_reverse_component_iterator4d rlast_back_bottom_right(const std::size_t component,
                                                const Box4d<int>& box) const;

                //------------------------ Range component iterators------------------------------------

                component_iterator4d_range first_front_upper_left(const std::size_t component,
                                                const slip::Range<int>& slab_range, const slip::Range<int>& slice_range,
                                                const slip::Range<int>& row_range,              const slip::Range<int>& col_range);

                component_iterator4d_range last_back_bottom_right(const std::size_t component,
                                                const slip::Range<int>& slab_range, const slip::Range<int>& slice_range,
                                                const slip::Range<int>& row_range,              const slip::Range<int>& col_range);

                const_component_iterator4d_range first_front_upper_left(const std::size_t component,
                                                const slip::Range<int>& slab_range, const slip::Range<int>& slice_range,
                                                const slip::Range<int>& row_range,              const slip::Range<int>& col_range) const;

                const_component_iterator4d_range last_back_bottom_right(const std::size_t component,
                                                const slip::Range<int>& slab_range, const slip::Range<int>& slice_range,
                                                const slip::Range<int>& row_range,              const slip::Range<int>& col_range) const;

                reverse_component_iterator4d_range rfirst_front_upper_left(const std::size_t component,
                                                const slip::Range<int>& slab_range, const slip::Range<int>& slice_range,
                                                const slip::Range<int>& row_range,              const slip::Range<int>& col_range);

                reverse_component_iterator4d_range rlast_back_bottom_right(const std::size_t component,
                                                const slip::Range<int>& slab_range, const slip::Range<int>& slice_range,
                                                const slip::Range<int>& row_range,              const slip::Range<int>& col_range);

                const_reverse_component_iterator4d_range rfirst_front_upper_left(const std::size_t component,
                                                const slip::Range<int>& slab_range, const slip::Range<int>& slice_range,
                                                const slip::Range<int>& row_range,              const slip::Range<int>& col_range) const;

                const_reverse_component_iterator4d_range rlast_back_bottom_right(const std::size_t component,
                                                const slip::Range<int>& slab_range, const slip::Range<int>& slice_range,
                                                const slip::Range<int>& row_range,              const slip::Range<int>& col_range) const;


                friend std::ostream& operator<< <>(std::ostream & out, const self& a);


                self& operator=(const self & rhs);

                self& operator=(const Block& val);

                self& operator=(const typename Block::value_type& val);

                void fill(const Block& value)
                {
                                std::fill_n(this->begin(),size(),value);
                }

                void fill(const typename Block::pointer value)
                {
                                std::copy(value,value + size(), (typename Block::pointer)begin());
                }

                void fill(const Block* value)
                {
                                std::copy(value,value + size(), this->begin());
                }

                template<typename InputIterator>
                void fill(InputIterator first,
                                                InputIterator last)
                {
                                std::copy(first,last,this->begin());
                }

                template<typename InputIterator>
                void fill(std::vector<InputIterator> first_iterators_list,
                                                InputIterator last)
                {
                                std::vector<typename slip::kstride_iterator<typename Block::pointer,Block::SIZE> >
                                iterators_list(Block::SIZE);

                                for(std::size_t component = 0; component < Block::SIZE; ++component)
                                {
                                                iterators_list[component]= slip::kstride_iterator<typename Block::pointer,Block::SIZE>
                                                ((typename Block::pointer)this->begin() + component);
                                }


                                while(first_iterators_list[0] != last)
                                {
                                                for(std::size_t component = 0; component < Block::SIZE; ++component)
                                                {
                                                                *iterators_list[component]++ = *first_iterators_list[component]++;
                                                }
                                }
                                iterators_list.clear();
                }


                template<typename InputIterator>
                void fill(std::size_t component,
                                                InputIterator first,
                                                InputIterator last)
                {
                                std::copy(first,last,this->begin(component));
                }

                friend bool operator== <>(const GenericMultiComponent4d<Block>& x,
                                                const GenericMultiComponent4d<Block>& y);

                friend bool operator!= <>(const GenericMultiComponent4d<Block>& x,
                                                const GenericMultiComponent4d<Block>& y);

                //  /*!
                //   ** \brief Less than comparison operator (GenericMultiComponent4d ordering relation)
                //   ** \param x A %GenericMultiComponent4d
                //   ** \param y A %GenericMultiComponent4d of the same type of \a x
                //   ** \return true iff \a x is lexicographically less than \a y
                //   ** \pre x.size() == y.size()
                //   */
                //   friend bool operator< <>(const GenericMultiComponent4d<Block>& x,
                //                                                 const GenericMultiComponent4d<Block>& y);

                //  /*!
                //   ** \brief More than comparison operator
                //   ** \param x A %GenericMultiComponent4d
                //   ** \param y A %GenericMultiComponent4d of the same type of \a x
                //   ** \return true iff y > x
                //   ** \pre x.size() == y.size()
                //   */
                //   friend bool operator> <>(const GenericMultiComponent4d<Block>& x,
                //                                                 const GenericMultiComponent4d<Block>& y);

                //   /*!
                //   ** \brief Less than equal comparison operator
                //   ** \param x A %GenericMultiComponent4d
                //   ** \param y A %GenericMultiComponent4d of the same type of \a x
                //   ** \return true iff !(y > x)
                //   ** \pre x.size() == y.size()
                //   */
                //   friend bool operator<= <>(const GenericMultiComponent4d<Block>& x,
                //                                                  const GenericMultiComponent4d<Block>& y);

                //   /*!
                //   ** \brief More than equal comparison operator
                //   ** \param x A %GenericMultiComponent4d
                //   ** \param y A %GenericMultiComponent4d of the same type of \a x
                //   ** \return true iff !(x < y)
                //   ** \pre x.size() == y.size()
                //   */
                //   friend bool operator>= <>(const GenericMultiComponent4d<Block>& x,
                //                                                  const GenericMultiComponent4d<Block>& y);


                pointer** operator[](const size_type t);

                const_pointer* const * operator[](const size_type t) const;

                reference operator()(const size_type t,
                                                const size_type k,
                                                const size_type i,
                                                const size_type j);

                const_reference operator()(const size_type t,
                                                const size_type k,
                                                const size_type i,
                                                const size_type j) const;

                size_type dim1() const;

                size_type slabs() const;

                size_type dim2() const;

                size_type slices() const;


                size_type dim3() const;


                size_type rows() const;


                size_type dim4() const;

                size_type columns() const;

                size_type cols() const;


                size_type size() const;

                size_type max_size() const;

                bool empty()const;

                void swap(self& M);


                Block min() const;


                Block max() const;

                //  /*!
                //   ** \brief Returns the sums of the elements of the %GenericMultiComponent4d
                //   ** \pre size() != 0
                //   */
                //   Block sum() const;

                GenericMultiComponent4d<Block>& apply(Block(*fun)(Block));

                GenericMultiComponent4d<Block>& apply(Block(*fun)(const Block&));


private:
                Matrix4d<Block>* matrix_;
 private:
    friend class boost::serialization::access;
    template<class Archive>
    void save(Archive & ar, const unsigned int version) const
    {
      ar & this->matrix_;
    }
    template<class Archive>
    void load(Archive & ar, const unsigned int version)
    {
      ar & this->matrix_;
    }
    BOOST_SERIALIZATION_SPLIT_MEMBER();

}; // end of MultiComponent4dContainer group
}//slip::


namespace slip
{

template<typename Block>
inline
GenericMultiComponent4d<Block>::GenericMultiComponent4d():
matrix_(new Matrix4d<Block>()){}

template<typename Block>
inline
GenericMultiComponent4d<Block>::GenericMultiComponent4d(const GenericMultiComponent4d<Block>::size_type slabs,
                                const GenericMultiComponent4d<Block>::size_type slices, const GenericMultiComponent4d<Block>::size_type rows,
                                const GenericMultiComponent4d<Block>::size_type cols):
                                matrix_(new Matrix4d<Block>(slabs,slices,rows,cols)){}

template<typename Block>
inline
GenericMultiComponent4d<Block>::GenericMultiComponent4d(const GenericMultiComponent4d<Block>::size_type slabs,
                                const GenericMultiComponent4d<Block>::size_type slices, const GenericMultiComponent4d<Block>::size_type rows,
                                const GenericMultiComponent4d<Block>::size_type cols, const Block& val):
                                matrix_(new Matrix4d<Block>(slabs,slices,rows,cols,val)){}

template<typename Block>
inline
GenericMultiComponent4d<Block>::GenericMultiComponent4d(const GenericMultiComponent4d<Block>::size_type slabs,
                                const GenericMultiComponent4d<Block>::size_type slices, const GenericMultiComponent4d<Block>::size_type rows,
                                const GenericMultiComponent4d<Block>::size_type cols, typename Block::const_pointer val):
                                matrix_(new Matrix4d<Block>(slabs,slices,rows,cols)){
                typename Matrix4d<Block>::iterator it = matrix_->begin();
                typename Matrix4d<Block>::iterator ite = matrix_->end();
                for(;it!=ite; it++)
                {
                                for(typename GenericMultiComponent4d<Block>::size_type component = 0;
                                                                component < Block::SIZE; ++component)
                                {
                                                (*it)[component] = *val++;
                                }
                }
}

template<typename Block>
inline
GenericMultiComponent4d<Block>::GenericMultiComponent4d(const GenericMultiComponent4d<Block>::size_type slabs,
                                const GenericMultiComponent4d<Block>::size_type slices, const GenericMultiComponent4d<Block>::size_type rows,
                                const GenericMultiComponent4d<Block>::size_type cols, const Block* val):
                                matrix_(new Matrix4d<Block>(slabs,slices,rows,cols,val)){}

template<typename Block>
inline
GenericMultiComponent4d<Block>::GenericMultiComponent4d(const GenericMultiComponent4d<Block>& rhs):
matrix_(new Matrix4d<Block>(*rhs.matrix_)){}

template<typename Block>
inline
GenericMultiComponent4d<Block>::~GenericMultiComponent4d(){
                delete matrix_;
}

template<typename Block>
inline
void GenericMultiComponent4d<Block>::resize(const GenericMultiComponent4d<Block>::size_type slabs,
                                const GenericMultiComponent4d<Block>::size_type slices,
                                const GenericMultiComponent4d<Block>::size_type rows,
                                const GenericMultiComponent4d<Block>::size_type cols,
                                const Block& val){
                matrix_->resize(slabs,slices,rows,cols,val);
}


//****************************************************************************
//                          One dimensional iterators
//****************************************************************************

//----------------------Global iterators------------------------------


template<typename Block>
inline
typename GenericMultiComponent4d<Block>::iterator
GenericMultiComponent4d<Block>::begin(){
                return matrix_->begin();
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_iterator
GenericMultiComponent4d<Block>::begin() const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->begin();
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::iterator
GenericMultiComponent4d<Block>::end(){
                return matrix_->end();
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_iterator
GenericMultiComponent4d<Block>::end() const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->end();
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_iterator
GenericMultiComponent4d<Block>::rbegin(){
                return typename GenericMultiComponent4d<Block>::reverse_iterator(this->end());
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_iterator
GenericMultiComponent4d<Block>::rbegin() const{
                return typename GenericMultiComponent4d<Block>::const_reverse_iterator(this->end());
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_iterator
GenericMultiComponent4d<Block>::rend(){
                return typename GenericMultiComponent4d<Block>::reverse_iterator(this->begin());
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_iterator
GenericMultiComponent4d<Block>::rend() const{
                return typename GenericMultiComponent4d<Block>::const_reverse_iterator(this->begin());
}

//--------------------One dimensional slab iterators----------------------

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::slab_iterator
GenericMultiComponent4d<Block>::slab_begin(const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col){
                return matrix_->slab_begin(slice,row,col);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_slab_iterator
GenericMultiComponent4d<Block>::slab_begin(const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->slab_begin(slice,row,col);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::slab_iterator
GenericMultiComponent4d<Block>::slab_end(const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col){
                return matrix_->slab_end(slice,row,col);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_slab_iterator
GenericMultiComponent4d<Block>::slab_end(const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->slab_end(slice,row,col);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_slab_iterator
GenericMultiComponent4d<Block>::slab_rbegin(const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col){
                return matrix_->slab_rbegin(slice,row,col);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_slab_iterator
GenericMultiComponent4d<Block>::slab_rbegin(const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->slab_rbegin(slice,row,col);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_slab_iterator
GenericMultiComponent4d<Block>::slab_rend(const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col){
                return matrix_->slab_rend(slice,row,col);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_slab_iterator
GenericMultiComponent4d<Block>::slab_rend(const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->slab_rend(slice,row,col);
}

//--------------------One dimensional slice iterators----------------------

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::slice_iterator
GenericMultiComponent4d<Block>::slice_begin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col){
                return matrix_->slice_begin(slab,row,col);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_slice_iterator
GenericMultiComponent4d<Block>::slice_begin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->slice_begin(slab,row,col);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::slice_iterator
GenericMultiComponent4d<Block>::slice_end(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col){
                return matrix_->slice_end(slab,row,col);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_slice_iterator
GenericMultiComponent4d<Block>::slice_end(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->slice_end(slab,row,col);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_slice_iterator
GenericMultiComponent4d<Block>::slice_rbegin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col){
                return matrix_->slice_rbegin(slab,row,col);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_slice_iterator
GenericMultiComponent4d<Block>::slice_rbegin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->slice_rbegin(slab,row,col);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_slice_iterator
GenericMultiComponent4d<Block>::slice_rend(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col){
                return matrix_->slice_rend(slab,row,col);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_slice_iterator
GenericMultiComponent4d<Block>::slice_rend(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->slice_rend(slab,row,col);
}

//-------------------row iterators----------

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::row_iterator
GenericMultiComponent4d<Block>::row_begin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row){
                return matrix_->row_begin(slab,slice,row);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_row_iterator
GenericMultiComponent4d<Block>::row_begin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->row_begin(slab,slice,row);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::row_iterator
GenericMultiComponent4d<Block>::row_end(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row){
                return matrix_->row_end(slab,slice,row);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_row_iterator
GenericMultiComponent4d<Block>::row_end(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->row_end(slab,slice,row);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_row_iterator
GenericMultiComponent4d<Block>::row_rbegin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row){
                return matrix_->row_rbegin(slab,slice,row);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_row_iterator
GenericMultiComponent4d<Block>::row_rbegin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->row_rbegin(slab,slice,row);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_row_iterator
GenericMultiComponent4d<Block>::row_rend(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row){
                return matrix_->row_rend(slab,slice,row);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_row_iterator
GenericMultiComponent4d<Block>::row_rend(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->row_rend(slab,slice,row);
}

//-------------------Constant col iterators----------

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::col_iterator
GenericMultiComponent4d<Block>::col_begin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type col){
                return matrix_->col_begin(slab,slice,col);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_col_iterator
GenericMultiComponent4d<Block>::col_begin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type col) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->col_begin(slab,slice,col);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::col_iterator
GenericMultiComponent4d<Block>::col_end(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type col){
                return matrix_->col_end(slab,slice,col);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_col_iterator
GenericMultiComponent4d<Block>::col_end(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type col) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->col_end(slab,slice,col);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_col_iterator
GenericMultiComponent4d<Block>::col_rbegin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type col){
                return matrix_->col_rbegin(slab,slice,col);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_col_iterator
GenericMultiComponent4d<Block>::col_rbegin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type col) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->col_rbegin(slab,slice,col);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_col_iterator
GenericMultiComponent4d<Block>::col_rend(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type col){
                return matrix_->col_rend(slab,slice,col);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_col_iterator
GenericMultiComponent4d<Block>::col_rend(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type col) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->col_rend(slab,slice,col);
}

//------------------------slab range iterators -----------------------

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::slab_range_iterator
GenericMultiComponent4d<Block>::slab_begin(const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return matrix_->slab_begin(slice,row,col,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::slab_range_iterator
GenericMultiComponent4d<Block>::slab_end(const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return matrix_->slab_end(slice,row,col,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_slab_range_iterator
GenericMultiComponent4d<Block>::slab_begin(const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->slab_begin(slice,row,col,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_slab_range_iterator
GenericMultiComponent4d<Block>::slab_end(const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->slab_end(slice,row,col,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_slab_range_iterator
GenericMultiComponent4d<Block>::slab_rbegin(const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return matrix_->slab_rbegin(slice,row,col,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_slab_range_iterator
GenericMultiComponent4d<Block>::slab_rend(const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return matrix_->slab_rend(slice,row,col,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_slab_range_iterator
GenericMultiComponent4d<Block>::slab_rbegin(const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->slab_rbegin(slice,row,col,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_slab_range_iterator
GenericMultiComponent4d<Block>::slab_rend(const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->slab_rend(slice,row,col,range);
}

//------------------------slice range iterators -----------------------

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::slice_range_iterator
GenericMultiComponent4d<Block>::slice_begin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return matrix_->slice_begin(slab,row,col,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::slice_range_iterator
GenericMultiComponent4d<Block>::slice_end(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return matrix_->slice_end(slab,row,col,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_slice_range_iterator
GenericMultiComponent4d<Block>::slice_begin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->slice_begin(slab,row,col,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_slice_range_iterator
GenericMultiComponent4d<Block>::slice_end(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->slice_end(slab,row,col,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_slice_range_iterator
GenericMultiComponent4d<Block>::slice_rbegin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return matrix_->slice_rbegin(slab,row,col,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_slice_range_iterator
GenericMultiComponent4d<Block>::slice_rend(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return matrix_->slice_rend(slab,row,col,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_slice_range_iterator
GenericMultiComponent4d<Block>::slice_rbegin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->slice_rbegin(slab,row,col,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_slice_range_iterator
GenericMultiComponent4d<Block>::slice_rend(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->slice_rend(slab,row,col,range);
}

//------------------------row range iterators -----------------------

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::row_range_iterator
GenericMultiComponent4d<Block>::row_begin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const slip::Range<int>& range){
                return matrix_->row_begin(slab,slice,row,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::row_range_iterator
GenericMultiComponent4d<Block>::row_end(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const slip::Range<int>& range){
                return matrix_->row_end(slab,slice,row,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_row_range_iterator
GenericMultiComponent4d<Block>::row_begin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const slip::Range<int>& range) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->row_begin(slab,slice,row,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_row_range_iterator
GenericMultiComponent4d<Block>::row_end(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const slip::Range<int>& range) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->row_end(slab,slice,row,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_row_range_iterator
GenericMultiComponent4d<Block>::row_rbegin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const slip::Range<int>& range){
                return matrix_->row_rbegin(slab,slice,row,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_row_range_iterator
GenericMultiComponent4d<Block>::row_rend(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const slip::Range<int>& range){
                return matrix_->row_rend(slab,slice,row,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_row_range_iterator
GenericMultiComponent4d<Block>::row_rbegin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const slip::Range<int>& range) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->row_rbegin(slab,slice,row,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_row_range_iterator
GenericMultiComponent4d<Block>::row_rend(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row,
                                const slip::Range<int>& range) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->row_rend(slab,slice,row,range);
}

//------------------------col range iterators -----------------------

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::col_range_iterator
GenericMultiComponent4d<Block>::col_begin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return matrix_->col_begin(slab,slice,col,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::col_range_iterator
GenericMultiComponent4d<Block>::col_end(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return matrix_->col_end(slab,slice,col,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_col_range_iterator
GenericMultiComponent4d<Block>::col_begin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->col_begin(slab,slice,col,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_col_range_iterator
GenericMultiComponent4d<Block>::col_end(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->col_end(slab,slice,col,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_col_range_iterator
GenericMultiComponent4d<Block>::col_rbegin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return matrix_->col_rbegin(slab,slice,col,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_col_range_iterator
GenericMultiComponent4d<Block>::col_rend(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return matrix_->col_rend(slab,slice,col,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_col_range_iterator
GenericMultiComponent4d<Block>::col_rbegin(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->col_rbegin(slab,slice,col,range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_col_range_iterator
GenericMultiComponent4d<Block>::col_rend(const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->col_rend(slab,slice,col,range);
}

//****************************************************************************
//                          Four dimensional iterators
//****************************************************************************

//------------------------ Global iterators------------------------------------

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::iterator4d
GenericMultiComponent4d<Block>::first_front_upper_left(){
                return matrix_->first_front_upper_left();
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::iterator4d
GenericMultiComponent4d<Block>::last_back_bottom_right(){
                return matrix_->last_back_bottom_right();
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_iterator4d
GenericMultiComponent4d<Block>::first_front_upper_left() const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->first_front_upper_left();
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_iterator4d
GenericMultiComponent4d<Block>::last_back_bottom_right() const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->last_back_bottom_right();
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_iterator4d
GenericMultiComponent4d<Block>::rfirst_front_upper_left(){
                return matrix_->rfirst_front_upper_left();
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_iterator4d
GenericMultiComponent4d<Block>::rlast_back_bottom_right(){
                return matrix_->rlast_back_bottom_right();
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_iterator4d
GenericMultiComponent4d<Block>::rfirst_front_upper_left() const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->rfirst_front_upper_left();
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_iterator4d
GenericMultiComponent4d<Block>::rlast_back_bottom_right() const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->rlast_back_bottom_right();
}

//------------------------ Box iterators------------------------------------

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::iterator4d
GenericMultiComponent4d<Block>::first_front_upper_left(const Box4d<int>& box){
                return matrix_->first_front_upper_left(box);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::iterator4d
GenericMultiComponent4d<Block>::last_back_bottom_right(const Box4d<int>& box){
                return matrix_->last_back_bottom_right(box);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_iterator4d
GenericMultiComponent4d<Block>::first_front_upper_left(const Box4d<int>& box) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->first_front_upper_left(box);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_iterator4d
GenericMultiComponent4d<Block>::last_back_bottom_right(const Box4d<int>& box) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->last_back_bottom_right(box);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_iterator4d
GenericMultiComponent4d<Block>::rfirst_front_upper_left(const Box4d<int>& box){
                return matrix_->rfirst_front_upper_left(box);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_iterator4d
GenericMultiComponent4d<Block>::rlast_back_bottom_right(const Box4d<int>& box){
                return matrix_->rlast_back_bottom_right(box);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_iterator4d
GenericMultiComponent4d<Block>::rfirst_front_upper_left(const Box4d<int>& box) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->rfirst_front_upper_left(box);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_iterator4d
GenericMultiComponent4d<Block>::rlast_back_bottom_right(const Box4d<int>& box) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->rlast_back_bottom_right(box);
}

//------------------------ Range iterators------------------------------------

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::iterator4d_range
GenericMultiComponent4d<Block>::first_front_upper_left(const slip::Range<int>& slab_range,
                                const slip::Range<int>& slice_range, const slip::Range<int>& row_range,
                                const slip::Range<int>& col_range){
                return matrix_->first_front_upper_left(slab_range,slice_range,row_range,col_range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::iterator4d_range
GenericMultiComponent4d<Block>::last_back_bottom_right(const slip::Range<int>& slab_range,
                                const slip::Range<int>& slice_range, const slip::Range<int>& row_range,
                                const slip::Range<int>& col_range){
                return matrix_->last_back_bottom_right(slab_range,slice_range,row_range,col_range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_iterator4d_range
GenericMultiComponent4d<Block>::first_front_upper_left(const slip::Range<int>& slab_range,
                                const slip::Range<int>& slice_range, const slip::Range<int>& row_range,
                                const slip::Range<int>& col_range) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->first_front_upper_left(slab_range,slice_range,row_range,col_range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_iterator4d_range
GenericMultiComponent4d<Block>::last_back_bottom_right(const slip::Range<int>& slab_range,
                                const slip::Range<int>& slice_range, const slip::Range<int>& row_range,
                                const slip::Range<int>& col_range) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->last_back_bottom_right(slab_range,slice_range,row_range,col_range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_iterator4d_range
GenericMultiComponent4d<Block>::rfirst_front_upper_left(const slip::Range<int>& slab_range,
                                const slip::Range<int>& slice_range, const slip::Range<int>& row_range,
                                const slip::Range<int>& col_range){
                return matrix_->rfirst_front_upper_left(slab_range,slice_range,row_range,col_range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_iterator4d_range
GenericMultiComponent4d<Block>::rlast_back_bottom_right(const slip::Range<int>& slab_range,
                                const slip::Range<int>& slice_range, const slip::Range<int>& row_range,
                                const slip::Range<int>& col_range){
                return matrix_->rlast_back_bottom_right(slab_range,slice_range,row_range,col_range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_iterator4d_range
GenericMultiComponent4d<Block>::rfirst_front_upper_left(const slip::Range<int>& slab_range,
                                const slip::Range<int>& slice_range, const slip::Range<int>& row_range,
                                const slip::Range<int>& col_range) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->rfirst_front_upper_left(slab_range,slice_range,row_range,col_range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_iterator4d_range
GenericMultiComponent4d<Block>::rlast_back_bottom_right(const slip::Range<int>& slab_range,
                                const slip::Range<int>& slice_range, const slip::Range<int>& row_range,
                                const slip::Range<int>& col_range) const{
                Matrix4d<Block> const * tp(matrix_);
                return tp->rlast_back_bottom_right(slab_range,slice_range,row_range,col_range);
}



//********************************************************************************
//                         Component iterators
//********************************************************************************

//------------------------ Component iterators------------------------------------

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_iterator
GenericMultiComponent4d<Block>::begin(const std::size_t component){
                return typename GenericMultiComponent4d<Block>::component_iterator((typename Block::pointer)begin() + component);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_iterator
GenericMultiComponent4d<Block>::begin(const std::size_t component) const{
                return typename GenericMultiComponent4d<Block>::const_component_iterator((typename Block::const_pointer)begin() + component);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_iterator
GenericMultiComponent4d<Block>::end(const std::size_t component){
                return typename GenericMultiComponent4d<Block>::component_iterator((typename Block::pointer)end() + component);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_iterator
GenericMultiComponent4d<Block>::end(const std::size_t component) const{
                return typename GenericMultiComponent4d<Block>::const_component_iterator((typename Block::const_pointer)end() + component);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_iterator
GenericMultiComponent4d<Block>::rbegin(const std::size_t component){
                return typename GenericMultiComponent4d<Block>::reverse_component_iterator(this->end(component));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_iterator
GenericMultiComponent4d<Block>::rbegin(const std::size_t component) const{
                return typename GenericMultiComponent4d<Block>::const_reverse_component_iterator(this->end(component));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_iterator
GenericMultiComponent4d<Block>::rend(const std::size_t component){
                return typename GenericMultiComponent4d<Block>::reverse_component_iterator(this->begin(component));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_iterator
GenericMultiComponent4d<Block>::rend(const std::size_t component) const{
                return typename GenericMultiComponent4d<Block>::const_reverse_component_iterator(this->begin(component));
}

//--------------------One dimensional component slab iterators----------------------

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_slab_iterator
GenericMultiComponent4d<Block>::slab_begin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col){
                return typename GenericMultiComponent4d<Block>::component_slab_iterator(&((*this)[0][slice][row][col][component]),
                                                Block::SIZE * this->dim2() * this->dim3() * this->dim4());
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_slab_iterator
GenericMultiComponent4d<Block>::slab_begin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col) const{
                return typename GenericMultiComponent4d<Block>::const_component_slab_iterator(&((*this)[0][slice][row][col][component]),
                                                Block::SIZE * this->dim2() * this->dim3() * this->dim4());
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_slab_iterator
GenericMultiComponent4d<Block>::slab_end(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col){
                return ++(typename GenericMultiComponent4d<Block>::component_slab_iterator(&((*this)[this->dim1()-1][slice][row][col][component]),
                                                Block::SIZE * this->dim2() * this->dim3() * this->dim4()));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_slab_iterator
GenericMultiComponent4d<Block>::slab_end(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col) const{
                return ++(typename GenericMultiComponent4d<Block>::const_component_slab_iterator(&((*this)[this->dim1()-1][slice][row][col][component]),
                                                Block::SIZE * this->dim2() * this->dim3() * this->dim4()));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_slab_iterator
GenericMultiComponent4d<Block>::slab_rbegin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col){
                return typename GenericMultiComponent4d<Block>::reverse_component_slab_iterator(this->slab_end(component,slice,row,col));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_slab_iterator
GenericMultiComponent4d<Block>::slab_rbegin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col) const{
                return typename GenericMultiComponent4d<Block>::const_reverse_component_slab_iterator(this->slab_end(component,slice,row,col));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_slab_iterator
GenericMultiComponent4d<Block>::slab_rend(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col){
                return typename GenericMultiComponent4d<Block>::reverse_component_slab_iterator(this->slab_begin(component,slice,row,col));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_slab_iterator
GenericMultiComponent4d<Block>::slab_rend(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col) const{
                return typename GenericMultiComponent4d<Block>::const_reverse_component_slab_iterator(this->slab_begin(component,slice,row,col));
}

//--------------------One dimensional component slice iterators----------------------

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_slice_iterator
GenericMultiComponent4d<Block>::slice_begin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col){
                return GenericMultiComponent4d<Block>::component_slice_iterator(&((*this)[slab][0][row][col][component]),
                                                Block::SIZE * this->dim3() * this->dim4());
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_slice_iterator
GenericMultiComponent4d<Block>::slice_begin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col) const{
                return GenericMultiComponent4d<Block>::const_component_slice_iterator(&((*this)[slab][0][row][col][component]),
                                                Block::SIZE * this->dim3() * this->dim4());
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_slice_iterator
GenericMultiComponent4d<Block>::slice_end(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col){
                return ++(typename GenericMultiComponent4d<Block>::component_slice_iterator(&((*this)[slab][this->dim2()-1][row][col][component]),
                                                Block::SIZE * this->dim3() * this->dim4()));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_slice_iterator
GenericMultiComponent4d<Block>::slice_end(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col) const{
                return ++(typename GenericMultiComponent4d<Block>::const_component_slice_iterator(&((*this)[slab][this->dim2()-1][row][col][component]),
                                                Block::SIZE * this->dim3() * this->dim4()));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_slice_iterator
GenericMultiComponent4d<Block>::slice_rbegin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col){
                return typename GenericMultiComponent4d<Block>::reverse_component_slice_iterator(this->slice_end(component,slab,row,col));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_slice_iterator
GenericMultiComponent4d<Block>::slice_rbegin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col) const{
                return typename GenericMultiComponent4d<Block>::const_reverse_component_slice_iterator(this->slice_end(component,slab,row,col));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_slice_iterator
GenericMultiComponent4d<Block>::slice_rend(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col){
                return typename GenericMultiComponent4d<Block>::reverse_component_slice_iterator(this->slice_begin(component,slab,row,col));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_slice_iterator
GenericMultiComponent4d<Block>::slice_rend(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col) const{
                return typename GenericMultiComponent4d<Block>::const_reverse_component_slice_iterator(this->slice_begin(component,slab,row,col));
}

//-------------------row component iterators----------

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_row_iterator
GenericMultiComponent4d<Block>::row_begin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type row){
                return typename GenericMultiComponent4d<Block>::component_row_iterator(
                                                (typename Block::pointer)this->row_begin(slab,slice,row) + component);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_row_iterator
GenericMultiComponent4d<Block>::row_begin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type row) const{
                return typename GenericMultiComponent4d<Block>::const_component_row_iterator(
                                                (typename Block::const_pointer)this->row_begin(slab,slice,row) + component);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_row_iterator
GenericMultiComponent4d<Block>::row_end(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type row){
                return typename GenericMultiComponent4d<Block>::component_row_iterator(
                                                (typename Block::pointer)this->row_end(slab,slice,row) + component);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_row_iterator
GenericMultiComponent4d<Block>::row_end(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type row) const{
                return typename GenericMultiComponent4d<Block>::const_component_row_iterator(
                                                (typename Block::const_pointer)this->row_end(slab,slice,row) + component);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_row_iterator
GenericMultiComponent4d<Block>::row_rbegin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type row){
                return typename GenericMultiComponent4d<Block>::reverse_component_row_iterator(this->row_end(component,slab,slice,row));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_row_iterator
GenericMultiComponent4d<Block>::row_rbegin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type row) const{
                return typename GenericMultiComponent4d<Block>::const_reverse_component_row_iterator(this->row_end(component,slab,slice,row));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_row_iterator
GenericMultiComponent4d<Block>::row_rend(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type row){
                return typename GenericMultiComponent4d<Block>::reverse_component_row_iterator(this->row_begin(component,slab,slice,row));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_row_iterator
GenericMultiComponent4d<Block>::row_rend(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type row) const{
                return typename GenericMultiComponent4d<Block>::const_reverse_component_row_iterator(this->row_begin(component,slab,slice,row));
}

//-------------------Constant component col iterators----------

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_col_iterator
GenericMultiComponent4d<Block>::col_begin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,          const GenericMultiComponent4d<Block>::size_type col){
                return typename GenericMultiComponent4d<Block>::component_col_iterator(&((*this)[slab][slice][0][col][component]),
                                                Block::SIZE * this->dim4());
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_col_iterator
GenericMultiComponent4d<Block>::col_begin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,          const GenericMultiComponent4d<Block>::size_type col) const{
                return typename GenericMultiComponent4d<Block>::const_component_col_iterator(&((*this)[slab][slice][0][col][component]),
                                                Block::SIZE * this->dim4());
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_col_iterator
GenericMultiComponent4d<Block>::col_end(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,          const GenericMultiComponent4d<Block>::size_type col){
                return ++(typename GenericMultiComponent4d<Block>::component_col_iterator(&((*this)[slab][slice][this->dim3()-1][col][component]),
                                                Block::SIZE * this->dim4()));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_col_iterator
GenericMultiComponent4d<Block>::col_end(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,          const GenericMultiComponent4d<Block>::size_type col) const{
                return ++(typename GenericMultiComponent4d<Block>::const_component_col_iterator(&((*this)[slab][slice][this->dim3()-1][col][component]),
                                                Block::SIZE * this->dim4()));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_col_iterator
GenericMultiComponent4d<Block>::col_rbegin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,          const GenericMultiComponent4d<Block>::size_type col){
                return typename GenericMultiComponent4d<Block>::reverse_component_col_iterator(this->col_end(component,slab,slice,col));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_col_iterator
GenericMultiComponent4d<Block>::col_rbegin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,          const GenericMultiComponent4d<Block>::size_type col) const{
                return typename GenericMultiComponent4d<Block>::const_reverse_component_col_iterator(this->col_end(component,slab,slice,col));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_col_iterator
GenericMultiComponent4d<Block>::col_rend(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,          const GenericMultiComponent4d<Block>::size_type col){
                return typename GenericMultiComponent4d<Block>::reverse_component_col_iterator(this->col_begin(component,slab,slice,col));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_col_iterator
GenericMultiComponent4d<Block>::col_rend(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice,          const GenericMultiComponent4d<Block>::size_type col) const{
                return typename GenericMultiComponent4d<Block>::const_reverse_component_col_iterator(this->col_begin(component,slab,slice,col));
}

//------------------------component slab range iterators -----------------------

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_slab_range_iterator
GenericMultiComponent4d<Block>::slab_begin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return typename GenericMultiComponent4d<Block>::component_slab_range_iterator(&((*this)[range.start()][slice][row][col][component]),
                                                Block::SIZE * this->dim2() * this->dim3() * this->dim4() * range.stride());
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_slab_range_iterator
GenericMultiComponent4d<Block>::slab_end(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return ++(typename GenericMultiComponent4d<Block>::component_slab_range_iterator
                                                (&((*this)[range.start() + range.iterations() * range.stride()][slice][row][col][component]),
                                                                                Block::SIZE * this->dim2() * this->dim3() * this->dim4() * range.stride()));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_slab_range_iterator
GenericMultiComponent4d<Block>::slab_begin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                return typename GenericMultiComponent4d<Block>::const_component_slab_range_iterator(&((*this)[range.start()][slice][row][col][component]),
                                                Block::SIZE * this->dim2() * this->dim3() * this->dim4() * range.stride());
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_slab_range_iterator
GenericMultiComponent4d<Block>::slab_end(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                return ++(typename GenericMultiComponent4d<Block>::const_component_slab_range_iterator
                                                (&((*this)[range.start() + range.iterations() * range.stride()][slice][row][col][component]),
                                                                                Block::SIZE * this->dim2() * this->dim3() * this->dim4() * range.stride()));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_slab_range_iterator
GenericMultiComponent4d<Block>::slab_rbegin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return typename GenericMultiComponent4d<Block>::reverse_component_slab_range_iterator(this->slab_end(component,slice,row,col,range));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_slab_range_iterator
GenericMultiComponent4d<Block>::slab_rend(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return typename GenericMultiComponent4d<Block>::reverse_component_slab_range_iterator(this->slab_begin(component,slice,row,col,range));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_slab_range_iterator
GenericMultiComponent4d<Block>::slab_rbegin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                return typename GenericMultiComponent4d<Block>::const_reverse_component_slab_range_iterator(this->slab_end(component,slice,row,col,range));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_slab_range_iterator
GenericMultiComponent4d<Block>::slab_rend(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slice,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                return typename GenericMultiComponent4d<Block>::const_reverse_component_slab_range_iterator(this->slab_begin(component,slice,row,col,range));
}

//------------------------component slice range iterators -----------------------

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_slice_range_iterator
GenericMultiComponent4d<Block>::slice_begin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return typename GenericMultiComponent4d<Block>::component_slice_range_iterator(&((*this)[slab][range.start()][row][col][component]),
                                                Block::SIZE * this->dim3() * this->dim4() * range.stride());
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_slice_range_iterator
GenericMultiComponent4d<Block>::slice_end(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return ++(typename GenericMultiComponent4d<Block>::component_slice_range_iterator
                                                (&((*this)[slab][range.start() + range.iterations() * range.stride()][row][col][component]),
                                                                                Block::SIZE * this->dim3() * this->dim4() * range.stride()));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_slice_range_iterator
GenericMultiComponent4d<Block>::slice_begin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                return typename GenericMultiComponent4d<Block>::const_component_slice_range_iterator(&((*this)[slab][range.start()][row][col][component]),
                                                Block::SIZE * this->dim3() * this->dim4() * range.stride());
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_slice_range_iterator
GenericMultiComponent4d<Block>::slice_end(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                return ++(typename GenericMultiComponent4d<Block>::const_component_slice_range_iterator
                                                (&((*this)[slab][range.start() + range.iterations() * range.stride()][row][col][component]),
                                                                                Block::SIZE * this->dim3() * this->dim4() * range.stride()));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_slice_range_iterator
GenericMultiComponent4d<Block>::slice_rbegin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return typename GenericMultiComponent4d<Block>::reverse_component_slice_range_iterator(this->slice_end(component,slab,row,col,range));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_slice_range_iterator
GenericMultiComponent4d<Block>::slice_rend(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return typename GenericMultiComponent4d<Block>::reverse_component_slice_range_iterator(this->slice_begin(component,slab,row,col,range));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_slice_range_iterator
GenericMultiComponent4d<Block>::slice_rbegin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                return typename GenericMultiComponent4d<Block>::const_reverse_component_slice_range_iterator(this->slice_end(component,slab,row,col,range));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_slice_range_iterator
GenericMultiComponent4d<Block>::slice_rend(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type row, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                return typename GenericMultiComponent4d<Block>::const_reverse_component_slice_range_iterator(this->slice_begin(component,slab,row,col,range));
}

//------------------------component row range iterators -----------------------

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_row_range_iterator
GenericMultiComponent4d<Block>::row_begin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type row,
                                const slip::Range<int>& range){
                return typename GenericMultiComponent4d<Block>::component_row_range_iterator
                                                (&((*this)[slab][slice][row][range.start()][component]), Block::SIZE * range.stride());
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_row_range_iterator
GenericMultiComponent4d<Block>::row_end(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type row,
                                const slip::Range<int>& range){
                return ++(typename GenericMultiComponent4d<Block>::component_row_range_iterator
                                                (&((*this)[slab][slice][row][range.start()+ range.iterations() * range.stride()][component]), Block::SIZE * range.stride()));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_row_range_iterator
GenericMultiComponent4d<Block>::row_begin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type row,
                                const slip::Range<int>& range) const{
                return typename GenericMultiComponent4d<Block>::const_component_row_range_iterator
                                                (&((*this)[slab][slice][row][range.start()][component]), Block::SIZE * range.stride());
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_row_range_iterator
GenericMultiComponent4d<Block>::row_end(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type row,
                                const slip::Range<int>& range) const{
                return ++(typename GenericMultiComponent4d<Block>::const_component_row_range_iterator
                                                (&((*this)[slab][slice][row][range.start()+ range.iterations() * range.stride()][component]), Block::SIZE * range.stride()));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_row_range_iterator
GenericMultiComponent4d<Block>::row_rbegin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type row,
                                const slip::Range<int>& range){
                return typename GenericMultiComponent4d<Block>::reverse_component_row_range_iterator(this->row_end(component,slab,slice,row,range));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_row_range_iterator
GenericMultiComponent4d<Block>::row_rend(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type row,
                                const slip::Range<int>& range){
                return typename GenericMultiComponent4d<Block>::reverse_component_row_range_iterator(this->row_begin(component,slab,slice,row,range));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_row_range_iterator
GenericMultiComponent4d<Block>::row_rbegin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type row,
                                const slip::Range<int>& range) const{
                return typename GenericMultiComponent4d<Block>::const_reverse_component_row_range_iterator(this->row_end(component,slab,slice,row,range));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_row_range_iterator
GenericMultiComponent4d<Block>::row_rend(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type row,
                                const slip::Range<int>& range) const{
                return typename GenericMultiComponent4d<Block>::const_reverse_component_row_range_iterator(this->row_begin(component,slab,slice,row,range));
}

//------------------------component col range iterators -----------------------

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_col_range_iterator
GenericMultiComponent4d<Block>::col_begin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return typename GenericMultiComponent4d<Block>::component_col_range_iterator(&((*this)[slab][slice][range.start()][col][component]),
                                                Block::SIZE * this->dim4() * range.stride());
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_col_range_iterator
GenericMultiComponent4d<Block>::col_end(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return ++(typename GenericMultiComponent4d<Block>::component_col_range_iterator
                                                (&((*this)[slab][slice][range.start()+ range.iterations() * range.stride()][col][component]),
                                                                                Block::SIZE * this->dim4() * range.stride()));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_col_range_iterator
GenericMultiComponent4d<Block>::col_begin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                return typename GenericMultiComponent4d<Block>::const_component_col_range_iterator(&((*this)[slab][slice][range.start()][col][component]),
                                                Block::SIZE * this->dim4() * range.stride());
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_col_range_iterator
GenericMultiComponent4d<Block>::col_end(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                return ++(typename GenericMultiComponent4d<Block>::const_component_col_range_iterator
                                                (&((*this)[slab][slice][range.start()+ range.iterations() * range.stride()][col][component]),
                                                                                Block::SIZE * this->dim4() * range.stride()));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_col_range_iterator
GenericMultiComponent4d<Block>::col_rbegin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return typename GenericMultiComponent4d<Block>::reverse_component_col_range_iterator(this->col_end(component,slab,slice,col,range));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_col_range_iterator
GenericMultiComponent4d<Block>::col_rend(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range){
                return typename GenericMultiComponent4d<Block>::reverse_component_col_range_iterator(this->col_begin(component,slab,slice,col,range));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_col_range_iterator
GenericMultiComponent4d<Block>::col_rbegin(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                return typename GenericMultiComponent4d<Block>::const_reverse_component_col_range_iterator(this->col_end(component,slab,slice,col,range));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_col_range_iterator
GenericMultiComponent4d<Block>::col_rend(const std::size_t component, const GenericMultiComponent4d<Block>::size_type slab,
                                const GenericMultiComponent4d<Block>::size_type slice, const GenericMultiComponent4d<Block>::size_type col,
                                const slip::Range<int>& range) const{
                return typename GenericMultiComponent4d<Block>::const_reverse_component_col_range_iterator(this->col_begin(component,slab,slice,col,range));
}

//****************************************************************************
//                          four dimensional component iterators
//****************************************************************************

//------------------------ Global component iterators------------------------------------

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_iterator4d
GenericMultiComponent4d<Block>::first_front_upper_left(const std::size_t component){
                return typename GenericMultiComponent4d<Block>::component_iterator4d
                                                (this,component,Box4d<int>(0,0,0,0,this->dim1()-1,this->dim2()-1,this->dim3()-1,this->dim4()-1));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_iterator4d
GenericMultiComponent4d<Block>::last_back_bottom_right(const std::size_t component){
                DPoint4d<int> dp(this->dim1(),this->dim2(),this->dim3(),this->dim4());
                typename GenericMultiComponent4d<Block>::component_iterator4d it =
                                                (*this).first_front_upper_left(component) + dp;
                return it;
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_iterator4d
GenericMultiComponent4d<Block>::first_front_upper_left(const std::size_t component) const{
                return typename GenericMultiComponent4d<Block>::const_component_iterator4d
                                                (this,component,Box4d<int>(0,0,0,0,this->dim1()-1,this->dim2()-1,this->dim3()-1,this->dim4()-1));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_iterator4d
GenericMultiComponent4d<Block>::last_back_bottom_right(const std::size_t component) const{
                DPoint4d<int> dp(this->dim1(),this->dim2(),this->dim3(),this->dim4());
                typename GenericMultiComponent4d<Block>::const_component_iterator4d it =
                                                (*this).first_front_upper_left(component) + dp;
                return it;
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_iterator4d
GenericMultiComponent4d<Block>::rfirst_front_upper_left(const std::size_t component){
                DPoint4d<int> dp(1,1,1,0);
                return typename GenericMultiComponent4d<Block>::reverse_component_iterator4d
                                                (this->last_back_bottom_right(component) - dp);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_iterator4d
GenericMultiComponent4d<Block>::rlast_back_bottom_right(const std::size_t component){
                return typename GenericMultiComponent4d<Block>::reverse_component_iterator4d
                                                (this->first_front_upper_left(component));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_iterator4d
GenericMultiComponent4d<Block>::rfirst_front_upper_left(const std::size_t component) const{
                DPoint4d<int> dp(1,1,1,0);
                return typename GenericMultiComponent4d<Block>::const_reverse_component_iterator4d
                                                (this->last_back_bottom_right(component) - dp);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_iterator4d
GenericMultiComponent4d<Block>::rlast_back_bottom_right(const std::size_t component) const{
                return typename GenericMultiComponent4d<Block>::const_reverse_component_iterator4d
                                                (this->first_front_upper_left(component));
}

//------------------------ Box component iterators------------------------------------

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_iterator4d
GenericMultiComponent4d<Block>::first_front_upper_left(const std::size_t component,
                                const Box4d<int>& box){
                return typename GenericMultiComponent4d<Block>::component_iterator4d(this,component,box);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_iterator4d
GenericMultiComponent4d<Block>::last_back_bottom_right(const std::size_t component,
                                const Box4d<int>& box){
                DPoint4d<int> dp(box.duration(),box.depth(),box.height(),box.width());
                return (typename GenericMultiComponent4d<Block>::component_iterator4d
                                                ((*this).first_front_upper_left(component,box) + dp));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_iterator4d
GenericMultiComponent4d<Block>::first_front_upper_left(const std::size_t component,
                                const Box4d<int>& box) const{
                return typename GenericMultiComponent4d<Block>::const_component_iterator4d(this,component,box);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_iterator4d
GenericMultiComponent4d<Block>::last_back_bottom_right(const std::size_t component,
                                const Box4d<int>& box) const{
                DPoint4d<int> dp(box.duration(),box.depth(),box.height(),box.width());
                return (typename GenericMultiComponent4d<Block>::const_component_iterator4d
                                                ((*this).first_front_upper_left(component,box) + dp));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_iterator4d
GenericMultiComponent4d<Block>::rfirst_front_upper_left(const std::size_t component,
                                const Box4d<int>& box){
                DPoint4d<int> dp(1,1,1,0);
                return typename GenericMultiComponent4d<Block>::reverse_component_iterator4d
                                                (this->last_back_bottom_right(component,box) - dp);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_iterator4d
GenericMultiComponent4d<Block>::rlast_back_bottom_right(const std::size_t component,
                                const Box4d<int>& box){
                return typename GenericMultiComponent4d<Block>::reverse_component_iterator4d
                                                (this->first_front_upper_left(component,box));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_iterator4d
GenericMultiComponent4d<Block>::rfirst_front_upper_left(const std::size_t component,
                                const Box4d<int>& box) const{
                DPoint4d<int> dp(1,1,1,0);
                return typename GenericMultiComponent4d<Block>::const_reverse_component_iterator4d
                                                (this->last_back_bottom_right(component,box) - dp);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_iterator4d
GenericMultiComponent4d<Block>::rlast_back_bottom_right(const std::size_t component,
                                const Box4d<int>& box) const{
                return typename GenericMultiComponent4d<Block>::const_reverse_component_iterator4d
                                                (this->first_front_upper_left(component,box));
}

//------------------------ Range component iterators------------------------------------

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_iterator4d_range
GenericMultiComponent4d<Block>::first_front_upper_left(const std::size_t component,
                                const slip::Range<int>& slab_range, const slip::Range<int>& slice_range,
                                const slip::Range<int>& row_range,              const slip::Range<int>& col_range){
                return typename GenericMultiComponent4d<Block>::component_iterator4d_range
                                                (this,component,slab_range,slice_range,row_range,col_range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::component_iterator4d_range
GenericMultiComponent4d<Block>::last_back_bottom_right(const std::size_t component,
                                const slip::Range<int>& slab_range, const slip::Range<int>& slice_range,
                                const slip::Range<int>& row_range,              const slip::Range<int>& col_range){
                DPoint4d<int> dp(slab_range.iterations()+1,slice_range.iterations()+1,row_range.iterations()+1,col_range.iterations()+1);
                return typename GenericMultiComponent4d<Block>::component_iterator4d_range
                                                ((*this).first_front_upper_left(component,slab_range,slice_range,row_range,col_range) + dp);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_iterator4d_range
GenericMultiComponent4d<Block>::first_front_upper_left(const std::size_t component,
                                const slip::Range<int>& slab_range, const slip::Range<int>& slice_range,
                                const slip::Range<int>& row_range,              const slip::Range<int>& col_range) const{
                return typename GenericMultiComponent4d<Block>::const_component_iterator4d_range
                                                (this,component,slab_range,slice_range,row_range,col_range);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_component_iterator4d_range
GenericMultiComponent4d<Block>::last_back_bottom_right(const std::size_t component,
                                const slip::Range<int>& slab_range, const slip::Range<int>& slice_range,
                                const slip::Range<int>& row_range,              const slip::Range<int>& col_range) const{
                DPoint4d<int> dp(slab_range.iterations()+1,slice_range.iterations()+1,row_range.iterations()+1,col_range.iterations()+1);
                return typename GenericMultiComponent4d<Block>::const_component_iterator4d_range
                                                ((*this).first_front_upper_left(component,slab_range,slice_range,row_range,col_range) + dp);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_iterator4d_range
GenericMultiComponent4d<Block>::rfirst_front_upper_left(const std::size_t component,
                                const slip::Range<int>& slab_range, const slip::Range<int>& slice_range,
                                const slip::Range<int>& row_range,              const slip::Range<int>& col_range){
                DPoint4d<int> dp(1,1,1,0);
                return typename GenericMultiComponent4d<Block>::reverse_component_iterator4d_range
                                                (this->last_back_bottom_right(component,slab_range,slice_range,row_range,col_range) - dp);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reverse_component_iterator4d_range
GenericMultiComponent4d<Block>::rlast_back_bottom_right(const std::size_t component,
                                const slip::Range<int>& slab_range, const slip::Range<int>& slice_range,
                                const slip::Range<int>& row_range,              const slip::Range<int>& col_range){
                return typename GenericMultiComponent4d<Block>::reverse_component_iterator4d_range
                                                (this->first_front_upper_left(component,slab_range,slice_range,row_range,col_range));
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_iterator4d_range
GenericMultiComponent4d<Block>::rfirst_front_upper_left(const std::size_t component,
                                const slip::Range<int>& slab_range, const slip::Range<int>& slice_range,
                                const slip::Range<int>& row_range,              const slip::Range<int>& col_range) const{
                DPoint4d<int> dp(1,1,1,0);
                return typename GenericMultiComponent4d<Block>::const_reverse_component_iterator4d_range
                                                (this->last_back_bottom_right(component,slab_range,slice_range,row_range,col_range) - dp);
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reverse_component_iterator4d_range
GenericMultiComponent4d<Block>::rlast_back_bottom_right(const std::size_t component,
                                const slip::Range<int>& slab_range, const slip::Range<int>& slice_range,
                                const slip::Range<int>& row_range,              const slip::Range<int>& col_range) const{
                return typename GenericMultiComponent4d<Block>::const_reverse_component_iterator4d_range
                                                (this->first_front_upper_left(component,slab_range,slice_range,row_range,col_range));
}

// i/o operators

template<typename Block>
inline
std::ostream& operator<<(std::ostream & out, const GenericMultiComponent4d<Block>& a){
                out << *(a.matrix_);
                out << std::endl;
                return out;
}

//  Assignment operators and methods
template<typename Block>
inline
GenericMultiComponent4d<Block>& GenericMultiComponent4d<Block>::operator=
                                (const GenericMultiComponent4d<Block> & rhs){
                if(this != &rhs)
                {
                                *matrix_ = *(rhs.matrix_);
                }
                return *this;
}

template<typename Block>
inline
GenericMultiComponent4d<Block>& GenericMultiComponent4d<Block>::operator=
                                (const Block& val){
                std::fill_n(matrix_->begin(),matrix_->size(),val);
                return *this;
}

template<typename Block>
inline
GenericMultiComponent4d<Block>& GenericMultiComponent4d<Block>::operator=
                                (const typename Block::value_type& val){
                std::fill_n(matrix_->begin(),matrix_->size(),val);
                return *this;
}

// Comparison operators
template<typename Block>
inline
bool operator==(const GenericMultiComponent4d<Block>& x,
                                const GenericMultiComponent4d<Block>& y){
                return ( x.size() == y.size()
                                                && std::equal(x.begin(),x.end(),y.begin()));
}

template<typename Block>
inline
bool operator!=(const GenericMultiComponent4d<Block>& x,
                                const GenericMultiComponent4d<Block>& y){
                return !(x == y);
}

//  Element access operators
template<typename Block>
inline
typename GenericMultiComponent4d<Block>::pointer**
GenericMultiComponent4d<Block>::operator[](const GenericMultiComponent4d<Block>::size_type t){
                return (*matrix_)[t];
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_pointer* const *
GenericMultiComponent4d<Block>::operator[](const GenericMultiComponent4d<Block>::size_type t) const{
                Matrix4d<Block> const *tp(matrix_);
                return (*tp)[t];
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::reference
GenericMultiComponent4d<Block>::operator()(const GenericMultiComponent4d<Block>::size_type t,
                                const GenericMultiComponent4d<Block>::size_type k,
                                const GenericMultiComponent4d<Block>::size_type i,
                                const GenericMultiComponent4d<Block>::size_type j){
                return (*matrix_)[t][k][i][j];
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::const_reference
GenericMultiComponent4d<Block>::operator()(const GenericMultiComponent4d<Block>::size_type t,
                                const GenericMultiComponent4d<Block>::size_type k,
                                const GenericMultiComponent4d<Block>::size_type i,
                                const GenericMultiComponent4d<Block>::size_type j) const{
                Matrix4d<Block> const *tp(matrix_);
                return (*tp)[t][k][i][j];
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::size_type
GenericMultiComponent4d<Block>::dim1() const{
                return matrix_->dim1();
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::size_type
GenericMultiComponent4d<Block>::slabs() const{
                return matrix_->dim1();
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::size_type
GenericMultiComponent4d<Block>::dim2() const{
                return matrix_->dim2();
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::size_type
GenericMultiComponent4d<Block>::slices() const{
                return matrix_->dim2();
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::size_type
GenericMultiComponent4d<Block>::dim3() const{
                return matrix_->dim3();
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::size_type
GenericMultiComponent4d<Block>::rows() const{
                return matrix_->dim3();
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::size_type
GenericMultiComponent4d<Block>::dim4() const{
                return matrix_->dim4();
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::size_type
GenericMultiComponent4d<Block>::columns() const{
                return matrix_->dim4();
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::size_type
GenericMultiComponent4d<Block>::cols() const{
                return matrix_->dim4();
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::size_type
GenericMultiComponent4d<Block>::size() const{
                return matrix_->size();
}

template<typename Block>
inline
typename GenericMultiComponent4d<Block>::size_type
GenericMultiComponent4d<Block>::max_size() const{
                return matrix_->max_size();
}

template<typename Block>
inline
bool
GenericMultiComponent4d<Block>::empty()const{
                return matrix_->empty();
}

template<typename Block>
inline
void
GenericMultiComponent4d<Block>::swap(GenericMultiComponent4d<Block>& M){
                matrix_->swap(*(M.matrix_));
}

template<typename Block>
inline
Block
GenericMultiComponent4d<Block>::min() const{
                Block tmp;
                for(typename GenericMultiComponent4d<Block>::size_type component = 0; component < Block::SIZE; ++component)
                {
                                typename Block::value_type min = *std::min_element(this->begin(component),this->end(component));
                                tmp[component] = min;
                }
                return tmp;
}

template<typename Block>
inline
Block
GenericMultiComponent4d<Block>::max() const{
                Block tmp;
                for(typename GenericMultiComponent4d<Block>::size_type component = 0; component < Block::SIZE; ++component)
                {
                                typename Block::value_type max = *std::max_element(this->begin(component),this->end(component));
                                tmp[component] = max;
                }
                return tmp;
}

template<typename Block>
inline
GenericMultiComponent4d<Block>&
GenericMultiComponent4d<Block>::apply(Block(*fun)(Block)){
                matrix_->apply(fun);
                return *this;
}

template<typename Block>
inline
GenericMultiComponent4d<Block>&
GenericMultiComponent4d<Block>::apply(Block(*fun)(const Block&)){
                matrix_->apply(fun);
                return *this;
}

}//slip::

#endif //SLIP_GENERICMULTICOMPONENT4D_HPP