Head

GCC Code Coverage Report
Directory:	./		Exec	Total	Coverage
File:	src/PTensor_impl.h	Lines:	270	297	90.9 %
Date:	2026-03-27 22:08:32	Branches:	98	126	77.8 %

/***************************************
	Auteur : Pierre Aubert
	Mail : pierre.aubert@lapp.in2p3.fr
	Licence : CeCILL-C
****************************************/

#ifndef __PTENSOR_H_IMPL__
#define __PTENSOR_H_IMPL__

#include "block_copy.h"
#include "PTensor.h"

///Default constructeur of PTensor
/**	@param allocMode : allocation mode (AllocMode::NONE, AllocMode::ALIGNED, AllocMode::PADDING)
 * 	@param tabShape : shape of the table to be allocated
 * 	@param nbDim : number of dimensions of the PTensor
*/
template<typename T>
PTensor<T>::PTensor(AllocMode::AllocMode allocMode, const size_t * tabShape, size_t nbDim){
	initialisationPTensor(allocMode, tabShape, nbDim);
}

///Default constructeur of PTensor
/**	@param allocMode : allocation mode (AllocMode::NONE, AllocMode::ALIGNED, AllocMode::PADDING)
 * 	@param nbElement : number of elemnts to be allocated
*/
template<typename T>
PTensor<T>::PTensor(AllocMode::AllocMode allocMode, size_t nbElement){
	size_t tabShape[1];
	tabShape[0] = nbElement;
	initialisationPTensor(allocMode, tabShape, 1lu);
}

///Default constructeur of PTensor
/**	@param allocMode : allocation mode (AllocMode::NONE, AllocMode::ALIGNED, AllocMode::PADDING)
 * 	@param nbRow : number of rows to be allocated
 * 	@param nbCol : number of columns to be allocated
*/
template<typename T>
PTensor<T>::PTensor(AllocMode::AllocMode allocMode, size_t nbRow, size_t nbCol){
	size_t tabShape[2];
	tabShape[0] = nbRow;
	tabShape[1] = nbCol;
	initialisationPTensor(allocMode, tabShape, 2lu);
}

///Default constructeur of PTensor
/**	@param allocMode : allocation mode (AllocMode::NONE, AllocMode::ALIGNED, AllocMode::PADDING)
 * 	@param nbSlice : number of slices to be allocated
 * 	@param nbRow : number of rows to be allocated
 * 	@param nbCol : number of columns to be allocated
*/
template<typename T>
PTensor<T>::PTensor(AllocMode::AllocMode allocMode, size_t nbSlice, size_t nbRow, size_t nbCol){
	size_t tabShape[3];
	tabShape[0] = nbSlice;
	tabShape[1] = nbRow;
	tabShape[2] = nbCol;

	initialisationPTensor(allocMode, tabShape, 3lu);
}

///Copy constructor of PTensor
/**	@param other : class to copy
*/
template<typename T>
PTensor<T>::PTensor(const PTensor<T> & other){
	initialisationPTensor(AllocMode::NONE, NULL, 0lu);
	copyPTensor(other);
}

///Destructor of PTensor
template<typename T>
PTensor<T>::~PTensor(){
	freeTabData();
	if(p_shape != NULL){delete [] p_shape;}
	if(p_reservedShape != NULL){delete [] p_reservedShape;}
}

///Definition of equal operator of PTensor
/**	@param other : class to copy
 * 	@return copied class
*/
template<typename T>
PTensor<T> & PTensor<T>::operator = (const PTensor<T> & other){
	copyPTensor(other);
	return *this;
}

///Reserve allocated memory to the PTensor, without resizing it
/**	@param tabDim : table of the size of each dimensions
 * 	@param nbDim : number of dimensions
 * 	@return true if the resize/reserve has been done, false otherwise
*/
template<typename T>
bool PTensor<T>::reserve(const size_t * tabDim, size_t nbDim){
	if(tensor_isSameShape(p_reservedShape, p_reservedNbDimension, tabDim, nbDim)){return false;}
	tensor_copyShape(p_reservedShape, p_reservedNbDimension, tabDim, nbDim);
	freeTabData();
	p_tabData = template_alloc<T>(p_padding, p_isAligned, p_allocMode, tabDim, nbDim);
	p_isOwnData = true;
	return true;
}

///Resize the PTensor
/**	@param tabDim : table of the size of each dimensions
 * 	@param nbDim : number of dimensions
 * 	@return true if the resize/reserve has been done, false otherwise
*/
template<typename T>
bool PTensor<T>::resize(const size_t * tabDim, size_t nbDim){
	if(tabDim == NULL || nbDim == 0lu){return false;}
	if(tensor_isSameShape(p_shape, p_nbDimension, tabDim, nbDim)){return false;}
	tensor_copyShape(p_shape, p_nbDimension, tabDim, nbDim);
	bool b(reserve(tabDim, nbDim));
	if(tabDim != NULL && nbDim != 0lu){
		p_fullSize = tensor_getFullSize(p_shape, p_nbDimension);
		p_nbCol = (p_shape[p_nbDimension - 1lu]);
		p_fullNbRow = (p_fullSize/p_nbCol);
		p_fullPaddedSize = p_fullNbRow*(p_nbCol + p_padding);
	}
	return b;
}

///Reserve allocated memory to the PTensor, without resizing it
/**	@param allocMode : allocation mode (AllocMode::NONE, AllocMode::ALIGNED, AllocMode::PADDING)
 * 	@param tabDim : table of the size of each dimensions
 * 	@param nbDim : number of dimensions
 * 	@return true if the resize/reserve has been done, false otherwise
*/
template<typename T>
bool PTensor<T>::reserve(AllocMode::AllocMode allocMode, const size_t * tabDim, size_t nbDim){
	setAllocMode(allocMode);
	return reserve(tabDim, nbDim);
}

///Resize the PTensor
/**	@param allocMode : allocation mode (AllocMode::NONE, AllocMode::ALIGNED, AllocMode::PADDING)
 * 	@param tabDim : table of the size of each dimensions
 * 	@param nbDim : number of dimensions
 * 	@return true if the resize/reserve has been done, false otherwise
*/
template<typename T>
bool PTensor<T>::resize(AllocMode::AllocMode allocMode, const size_t * tabDim, size_t nbDim){
	setAllocMode(allocMode);
	return resize(tabDim, nbDim);
}

///Resize the PTensor
/**	@param allocMode : allocation mode (AllocMode::NONE, AllocMode::ALIGNED, AllocMode::PADDING)
 * 	@param nbValue : number of values
 * 	@return true if the resize/reserve has been done, false otherwise
*/
template<typename T>
bool PTensor<T>::resize(AllocMode::AllocMode allocMode, size_t nbValue){
	size_t dims[1];
	dims[0] = nbValue;
	return resize(allocMode, dims, 1lu);
}

///Resize the PTensor
/**	@param allocMode : allocation mode (AllocMode::NONE, AllocMode::ALIGNED, AllocMode::PADDING)
 * 	@param nbRow : number of rows
 * 	@param nbCol : number of columns
 * 	@return true if the resize/reserve has been done, false otherwise
*/
template<typename T>
bool PTensor<T>::resize(AllocMode::AllocMode allocMode, size_t nbRow, size_t nbCol){
	size_t dims[2];
	dims[0] = nbRow;
	dims[1] = nbCol;
	return resize(allocMode, dims, 2lu);
}

///Resize the PTensor
/**	@param allocMode : allocation mode (AllocMode::NONE, AllocMode::ALIGNED, AllocMode::PADDING)
 * 	@param nbSlice : number of slices (number of matrices or size nbRow, nbCol)
 * 	@param nbRow : number of rows
 * 	@param nbCol : number of columns
 * 	@return true if the resize/reserve has been done, false otherwise
*/
template<typename T>
bool PTensor<T>::resize(AllocMode::AllocMode allocMode, size_t nbSlice, size_t nbRow, size_t nbCol){
	size_t dims[3];
	dims[0] = nbSlice;
	dims[1] = nbRow;
	dims[2] = nbCol;
	return resize(allocMode, dims, 3lu);
}

///Load a binary table of value
/**	@param fileName : name of the file to be loaded
 * 	@param allocMode : allocation mode (AllocMode::NONE, AllocMode::ALIGNED, AllocMode::PADDING)
 * 	@return true on success, false otherwise
*/
template<typename T>
bool PTensor<T>::fromFile(const std::string & fileName, AllocMode::AllocMode allocMode){
	if(fileName == ""){return false;}
	FILE* fp = fopen(fileName.c_str(), "r");
	if(fp == NULL){
		std::cerr << " PTensor<T>::fromFile : can't load file '" << fileName << "'" << std::endl;
		return false;
	}
	fseek(fp, 0l, SEEK_END);
	size_t fileSize(ftell(fp));
	fseek(fp, 0l, SEEK_SET);
	size_t nbElement = fileSize/sizeof(T);
	resize(allocMode, nbElement);
	if(fread(p_tabData, sizeof(T), nbElement, fp) != nbElement){
		std::cerr << " PTensor<T>::fromFile : can't get "<<nbElement<<" unsigned short in file '" << fileName << "'" << std::endl;
		fclose(fp);
		freeTabData();
		return false;
	}
	fclose(fp);
	return true;
}

///Copy only the pointers of the data and shape
/**	@param tabData : pointer to the data
 * 	@param tabDim : table of dimension
 * 	@param nbDim : number of dimension
 * 	@param isAligned : true if the data pointer is aligned
 * 	@param padding : padding of the table of data
*/
template<typename T>
void PTensor<T>::copyPointer(T * tabData, size_t * tabDim, size_t nbDim, bool isAligned, size_t padding){
	p_isOwnData = false;
	p_tabData = tabData;

	tensor_copyShape(p_shape, p_nbDimension, tabDim, nbDim);
	tensor_copyShape(p_reservedShape, p_reservedNbDimension, tabDim, nbDim);

	p_isAligned = isAligned;
	p_padding = padding;

	p_fullSize = tensor_getFullSize(tabDim, nbDim);
	p_nbCol = tabDim[nbDim - 1lu];
	p_fullNbRow = p_fullSize/p_nbCol;

	p_fullPaddedSize = p_fullNbRow*(p_nbCol + p_padding);
	p_allocMode = tensor_getAllocMode(isAligned, padding);
}

///Change the allocation mode
/**	@param allocMode : allocation mode (AllocMode::NONE, AllocMode::ALIGNED, AllocMode::PADDING)
*/
template<typename T>
void PTensor<T>::setAllocMode(AllocMode::AllocMode allocMode){
	p_allocMode = allocMode;
}

///Fill the PTensor with a value
/**	@param value : value to fill
*/
template<typename T>
void PTensor<T>::fill(T value){
	if(p_tabData == NULL){return;}	//If there is nothing to fill, we quit
	for(size_t i(0lu); i < p_fullPaddedSize; ++i){
		p_tabData[i] = value;
	}
}

///Fill the PTensor with a table
/**	@param tabValue : table of values to be used
 * 	@param nbValue : number of value to be used
*/
template<typename T>
void PTensor<T>::setData(const T * tabValue, size_t nbValue){
	if(tabValue == NULL || nbValue == 0lu){return;}
	if(p_nbDimension != 1lu){throw std::runtime_error("PTensor<T>::setData : expect single dimension tensor");}
	if(p_fullSize != nbValue){throw std::runtime_error("PTensor<T>::setData : wrong number of elements");}
	for(size_t i(0lu); i < nbValue; ++i){
		p_tabData[i] = tabValue[i];
	}
}

///Fill the PTensor with a matrix
/**	@param tabValue : table of values to be used
 * 	@param nbRow : number of rows to be used
 * 	@param nbCol : number of columns to be used
*/
template<typename T>
void PTensor<T>::setData(const T * tabValue, size_t nbRow, size_t nbCol){
	if(tabValue == NULL || nbRow == 0lu || nbCol == 0lu){return;}
	if(p_nbDimension != 1lu){throw std::runtime_error("PTensor<T>::setData : expect two dimension tensor");}
	if(p_fullNbRow != nbRow){throw std::runtime_error("PTensor<T>::setData : wrong number of rows");}
	if(p_nbCol != nbCol){throw std::runtime_error("PTensor<T>::setData : wrong number of columns");}
	size_t rowSize(p_nbCol + p_padding);
	for(size_t i(0lu); i < nbRow; ++i){
		for(size_t j(0lu); j < nbCol; ++j){
			p_tabData[i*rowSize + j] = tabValue[i*nbCol + j];
		}
	}
}

///Set the value of an element of the tensor
/**	@param index : index of the element to be set
 * 	@param value : value to be set
*/
template<typename T>
void PTensor<T>::setValue(size_t index, T value){
	p_tabData[index] = value;
}

///Set the value of an element of the tensor
/**	@param indexRow : row index of the element to be set
 * 	@param indexCol : column index of the element to be set
 * 	@param value : value to be set
*/
template<typename T>
void PTensor<T>::setValue(size_t indexRow, size_t indexCol, T value){
	setValue(indexRow*(p_nbCol + p_padding) + indexCol, value);
}

///Set the padding value of the PTensor
/**	@param value : padding value of the PTensor
*/
template<typename T>
void PTensor<T>::setPaddingValue(T value){
	if(p_padding == 0lu || p_tabData == NULL){return;}	//If there is not padding or no data, we quit
	size_t rowSize(p_nbCol + p_padding);
	for(size_t i(0lu); i < p_fullNbRow; ++i){
		for(size_t j(0lu); j < p_nbCol; ++j){
			for(size_t k(0lu); k < p_padding; ++k){
				p_tabData[i*rowSize + j + k] = value;
			}
		}
	}
}

///Get the value of the padding
/**	@return padding value
*/
template<typename T>
T PTensor<T>::getPaddingValue() const{
	if(p_padding == 0lu || p_tabData == NULL){return (T)0;}
	return p_tabData[p_fullPaddedSize - 1lu];
}

///Set the size of the neighbours vector
/**	@param nbNeighbour : number of elements in the neighbours vector (scalar: 1, vectorial: n)
*/
template<typename T>
void PTensor<T>::setNbVecNeighbour(size_t nbNeighbour){
	p_nbNeighbour = nbNeighbour;
}

///Get the size of the neighbours vector
/**	@return number of elements in the neighbours vector (scalar: 1, vectorial: n)
*/
template<typename T>
size_t PTensor<T>::getNbVecNeighbour() const{
	return p_nbNeighbour;
}

///Convert the given tensor (with scalar neighbours), in vectorial neighbours
/**	@param tensorScal : input tensor (with scalar neighbours) to be converted
*/
template<typename T>
void PTensor<T>::fromScalToVecNeigbhour(const PTensor<T> & tensorScal){
	fromScalToVecNeigbhour(tensorScal, p_nbNeighbour);
}

///Convert the given tensor (with scalar neighbours), in vectorial neighbours
/**	@param tensorScal : input tensor (with scalar neighbours) to be converted
 * 	@param vectorSize : number of elements in the neighbours vector (scalar: 1, vectorial: n)
 * 	The allocation mode of the current Tensor is not changed and used as it was set
*/
template<typename T>
void PTensor<T>::fromScalToVecNeigbhour(const PTensor<T> & tensorScal, size_t vectorSize){
	p_nbNeighbour = vectorSize;

	size_t nbRow(tensorScal.getFullNbRow()), nbCol(tensorScal.getNbCol());

	size_t vecNbCol(nbCol*vectorSize);	//Vectorial number of columns
	//+2 is for the first and last rows where we dupplicate some values to increase the potential vectorisation of the computation
	size_t basicVecNbRow((nbRow/vectorSize) + (nbRow % vectorSize != 0lu));
	size_t vecNbRow(basicVecNbRow + 2lu);

	resize(p_allocMode, vecNbRow, vecNbCol);	//Let's allocate the new tensor with vectorial neighbours

	p_nbScalRow = nbRow;
	//Now, reshuffle data to vecotial mode
	for(size_t i(0lu); i < nbRow; ++i){
		size_t rowShift(i % basicVecNbRow);
		size_t vecRowIdx(rowShift + 1lu);
		size_t colShift(i / basicVecNbRow);
		for(size_t j(0lu); j < nbCol; ++j){
			size_t vecColIdx(j*vectorSize + colShift);
			setValue(vecRowIdx, vecColIdx, tensorScal.getValue(i, j));
		}
	}
	//Now let's deal with the dupplicated rows
	size_t nbDupplicate(vectorSize - 1lu), lastRow(vecNbRow - 1lu);
	for(size_t i(0lu); i < nbDupplicate; ++i){
		size_t duppliRowDownIdx((i + 1lu)*basicVecNbRow);
		size_t duppliRowUpIdx(duppliRowDownIdx - 1lu);

		//It is not a bug, the column shift down is given by the up row index
		size_t colShiftDown(duppliRowUpIdx / basicVecNbRow);

		for(size_t j(0lu); j < nbCol; ++j){
			size_t vecColDownIdx(j*vectorSize + colShiftDown);
			size_t vecColUpIdx(vecColDownIdx + 1lu);

			//Up row
			setValue(0lu, vecColUpIdx, tensorScal.getValue(duppliRowUpIdx, j));
			//Down row
			setValue(lastRow, vecColDownIdx, tensorScal.getValue(duppliRowDownIdx, j));
		}
	}
	//Then, let's put zeros at the rigth places to update padding values and avoid wrong computation
	for(size_t i(0lu); i < nbCol; ++i){
		setValue(0lu, i*vectorSize, 0.0f);			//First row padding
		setValue(lastRow, (i + 1lu)*vectorSize - 1lu, 0.0f);	//Last row padding
	}
	//Finally, the facultative padding (depending on the number of rows of the input scalar tensor)
	size_t nbFacultativePaddingRow((vectorSize - (nbRow % vectorSize)) % vectorSize);
	if(nbFacultativePaddingRow != 0lu){
		for(size_t i(0lu); i < nbFacultativePaddingRow; ++i){
			size_t paddingRowIdx(vecNbRow - i - 2lu);
			for(size_t j(0lu); j < nbCol; ++j){
				setValue(paddingRowIdx, (j + 1lu)*vectorSize - 1lu, 0.0f);	//Last row padding
			}
		}
	}
}

///Convert the given tensor (with vectorial neighbours), in scalar neighbours
/**	@param tensorVec : input tensor (with vectorial neighbours) to be converted
 * 	The allocation mode of the current Tensor is not changed and used as it was set
*/
template<typename T>
void PTensor<T>::fromVecToScalNeigbhour(const PTensor<T> & tensorVec){
	p_nbNeighbour = 1lu;

	size_t vectorSize(tensorVec.p_nbNeighbour);
	size_t vecNbRow(tensorVec.getFullNbRow()), nbVecCol(tensorVec.getNbCol());
	size_t nbCol(nbVecCol/vectorSize);		//Scalar number of columns
	size_t nbRow(tensorVec.p_nbScalRow);		//Scalart number of rows
	if(resize(p_allocMode, nbRow, nbCol)){		//Let's allocate the new tensor with scalar neighbours
		fill(0.0);				//If the resize has been done, we initialse the unused values
	}

	size_t basicVecNbRow((nbRow/vectorSize) + (nbRow % vectorSize != 0lu));
	p_nbScalRow = nbRow;
	//Now, reshuffle data back to scalar mode
	for(size_t i(0lu); i < nbRow; ++i){
		size_t rowShift(i % basicVecNbRow);
		size_t vecRowIdx(rowShift + 1lu);
		size_t colShift(i / basicVecNbRow);
		for(size_t j(0lu); j < nbCol; ++j){
			size_t vecColIdx(j*vectorSize + colShift);
			setValue(i, j, tensorVec.getValue(vecRowIdx, vecColIdx));
		}
	}
	//Now let's deal with the dupplicated rows
	size_t nbDupplicate(vectorSize - 1lu), lastCol(vecNbRow - 1lu);
	for(size_t i(0lu); i < nbDupplicate; ++i){
		size_t duppliRowDownIdx((i + 1lu)*basicVecNbRow);
		size_t duppliRowUpIdx(duppliRowDownIdx - 1lu);

		//It is not a bug, the column shift down is given by the up row index
		size_t colShiftDown(duppliRowUpIdx / basicVecNbRow);

		for(size_t j(0lu); j < nbCol; ++j){
			size_t vecColDownIdx(j*vectorSize + colShiftDown);
			size_t vecColUpIdx(vecColDownIdx + 1lu);

			//Up row
			setValue(duppliRowUpIdx, j, tensorVec.getValue(0lu, vecColUpIdx));
			//Down row
			setValue(duppliRowDownIdx, j, tensorVec.getValue(lastCol, vecColDownIdx));
		}
	}
}

///Update the value of the dupplicated vectorial neighbours with an average
template<typename T>
void PTensor<T>::updateDupplicateVecNeighbour(){
	size_t nbRow(getFullNbRow());
	if(nbRow < 4lu){return;}
	size_t lastRowIdx(nbRow - 1lu);
	size_t prevLastRowIdx(lastRowIdx - 1lu);
	size_t nbCompute(p_nbCol/p_nbNeighbour);
	size_t nbComputeVec(p_nbNeighbour - 1lu);
	for(size_t i(0lu); i < nbCompute; ++i){
		for(size_t j(0lu); j < nbComputeVec; ++j){
			setValue(0lu, i*p_nbNeighbour + 1lu + j, getValue(prevLastRowIdx, i*p_nbNeighbour + j));
			setValue(lastRowIdx, i*p_nbNeighbour + j, getValue(1lu, i*p_nbNeighbour + 1lu + j));
		}
	}
}

///Split the current PTensor in blocks of size blockSizeRow x blockSizeCol, never bigger, and can have a neighborRing (or border) around it
/**	@param[out] vecBlock : vector of PBlock
 * 	@param blockSizeRow : maximum size of the created block in rows (taking account the neighborRing)
 * 	@param blockSizeCol : maximum size of the created block in columns (taking account the neighborRing)
 * 	@param neighborRing : number of border ring to be added around the created blocks
*/
template<typename T>
void PTensor<T>::splitBlock(std::vector<PBlock<T> > & vecBlock, size_t blockSizeRow, size_t blockSizeCol, size_t neighborRing) const{
	size_t nbInBlockRow(0lu), sizeLastInBlockRow(0lu), nbInBlockCol(0lu), sizeLastInBlockCol(0lu), nbTotalBlock(0lu);
	updateBlockSize(nbTotalBlock, nbInBlockRow, nbInBlockCol,
			sizeLastInBlockRow, sizeLastInBlockCol,
			vecBlock, blockSizeRow, blockSizeCol, neighborRing);
	size_t nbCol(getNbCol());
	size_t blockIndex(0lu);
	for(size_t i(0lu); i < nbInBlockRow; ++i){		//Loop over block rows
		for(size_t j(0lu); j < nbInBlockCol; ++j){		//Loop over block columns
			copyTensorToBlock(vecBlock[blockIndex], nbCol, blockSizeRow, blockSizeCol,
					blockSizeRow, blockSizeCol, i, j, neighborRing);
			++blockIndex;
		}
		if(sizeLastInBlockCol != 0lu){	//There is a small block at the end of the row
			copyTensorToBlock(vecBlock[blockIndex], nbCol, blockSizeRow, sizeLastInBlockCol,
					blockSizeRow, blockSizeCol, i, nbInBlockCol, neighborRing);
			++blockIndex;
		}
	}
	if(sizeLastInBlockRow != 0lu){	//There is a small blocks row as last row
		for(size_t j(0lu); j < nbInBlockCol; ++j){		//Loop over block columns
			copyTensorToBlock(vecBlock[blockIndex], nbCol, sizeLastInBlockRow, blockSizeCol,
					blockSizeRow, blockSizeCol, nbInBlockRow, j, neighborRing);
			++blockIndex;
		}
		if(sizeLastInBlockCol != 0lu){	//There is a small block at the end of the row
			copyTensorToBlock(vecBlock[blockIndex], nbCol, sizeLastInBlockRow, sizeLastInBlockCol,
					blockSizeRow, blockSizeCol, nbInBlockRow, nbInBlockCol, neighborRing);
			++blockIndex;
		}
	}
}

///Merge the block values into the current PTensor
/**	@param vecBlock : vector of blocks to be merged
 * 	@param neighborRing : number of border ring to be added around blocks
*/
template<typename T>
void PTensor<T>::mergeBlock(const std::vector<PBlock<T> > & vecBlock, size_t neighborRing){
	for(typename std::vector<PBlock<T> >::const_iterator it(vecBlock.begin()); it != vecBlock.end(); ++it){
		block_copy_blockToTensor(p_tabData, getNbCol(), getPadding(),
				it->getData(), it->getFullNbRow(), it->getNbCol(), it->getPadding(),
				it->getLocationRow(), it->getLocationCol(), neighborRing, p_nbNeighbour);
	}
}

///Split the current PTensor in blocks of size blockSizeRow x blockSizeCol, never bigger, and can have a neighborRing (or border) around it (no data copy, just a link with pointer)
/**	@param[out] vecBlock : vector of PBlock
 * 	@param blockSizeRow : maximum size of the created block in rows (taking account the neighborRing)
 * 	@param blockSizeCol : maximum size of the created block in columns (taking account the neighborRing)
 * 	@param neighborRing : number of border ring to be added around the created blocks
*/
template<typename T>
void PTensor<T>::splitBlockLink(std::vector<PBlock<T> > & vecBlock, size_t blockSizeRow, size_t blockSizeCol, size_t neighborRing) const{
	size_t nbInBlockRow(0lu), sizeLastInBlockRow(0lu), nbInBlockCol(0lu), sizeLastInBlockCol(0lu), nbTotalBlock(0lu);
	updateBlockSize(nbTotalBlock, nbInBlockRow, nbInBlockCol,
			sizeLastInBlockRow, sizeLastInBlockCol,
			vecBlock, blockSizeRow, blockSizeCol, neighborRing);
	size_t nbCol(getNbCol());
	size_t blockIndex(0lu);
	for(size_t i(0lu); i < nbInBlockRow; ++i){		//Loop over block rows
		for(size_t j(0lu); j < nbInBlockCol; ++j){		//Loop over block columns
			linkTensorToBlock(vecBlock[blockIndex], nbCol, blockSizeRow, blockSizeCol,
					blockSizeRow, blockSizeCol, i, j, neighborRing);
			++blockIndex;
		}
		if(sizeLastInBlockCol != 0lu){	//There is a small block at the end of the row
			linkTensorToBlock(vecBlock[blockIndex], nbCol, blockSizeRow, sizeLastInBlockCol,
					blockSizeRow, blockSizeCol, i, nbInBlockCol, neighborRing);
			++blockIndex;
		}
	}
	if(sizeLastInBlockRow != 0lu){	//There is a small blocks row as last row
		for(size_t j(0lu); j < nbInBlockCol; ++j){		//Loop over block columns
			linkTensorToBlock(vecBlock[blockIndex], nbCol, sizeLastInBlockRow, blockSizeCol,
					blockSizeRow, blockSizeCol, nbInBlockRow, j, neighborRing);
			++blockIndex;
		}
		if(sizeLastInBlockCol != 0lu){	//There is a small block at the end of the row
			linkTensorToBlock(vecBlock[blockIndex], nbCol, sizeLastInBlockRow, sizeLastInBlockCol,
					blockSizeRow, blockSizeCol, nbInBlockRow, nbInBlockCol, neighborRing);
			++blockIndex;
		}
	}
}

///Get the number of dimensions of the PTensor
/**	@return number of dimensions of the PTensor
*/
template<typename T>
size_t PTensor<T>::getNbDim() const{return p_nbDimension;}

///Get the full size of the PTensor
/**	@return full size of the PTensor
*/
template<typename T>
size_t PTensor<T>::getFullSize() const{return p_fullSize;}

///Get the padding of the PTensor
/**	@return padding of the PTensor
*/
template<typename T>
size_t PTensor<T>::getPadding() const{return p_padding;}

///Say if the data of the PTensor is aligned
/**	@return true if the data of the PTensor is aligned, false otherwise
*/
template<typename T>
bool PTensor<T>::isAligned() const{return p_isAligned;}

///Get the number of columns of the tensor
/**	@return number of columns of the tensor
*/
template<typename T>
size_t PTensor<T>::getNbCol() const{return p_nbCol;}

///Get the full number of rows of the tensor (all dimension merged but without the last one)
/**	@return full number of rows of the tensor (all dimension merged but without the last one)
*/
template<typename T>
size_t PTensor<T>::getFullNbRow() const{return p_fullNbRow;}

///Get the allocation mode of the PTensor
/**	@return allocation mode of the PTensor
*/
template<typename T>
AllocMode::AllocMode PTensor<T>::getAllocMode() const{return p_allocMode;}

///Get the shape of the PTensor
/**	@return shape of the PTensor
*/
template<typename T>
const size_t * PTensor<T>::getShape() const{return p_shape;}

///Get the data of the PTensor
/**	@return data of the PTensor
*/
template<typename T>
const T * PTensor<T>::getData() const{return p_tabData;}

///Get the data of the PTensor
/**	@return data of the PTensor
*/
template<typename T>
T * PTensor<T>::getData(){return p_tabData;}

///Get the value at index
/**	@param index ; index of the value to get
 * 	@return value at index
*/
template<typename T>
const T & PTensor<T>::getValue(size_t index) const{
	return p_tabData[index];
}

///Get the value at index
/**	@param index ; index of the value to get
 * 	@return value at index
*/
template<typename T>
T & PTensor<T>::getValue(size_t index){
	return p_tabData[index];
}

///Get the value at index
/**	@param indexRow : row index of the value to get
 * 	@param indexCol : column index of the value to get
 * 	@return value at index
*/
template<typename T>
const T & PTensor<T>::getValue(size_t indexRow, size_t indexCol) const{
	return getValue(indexRow*(p_nbCol + p_padding) + indexCol);
}

///Get the value at index
/**	@param indexRow : row index of the value to get
 * 	@param indexCol : column index of the value to get
 * 	@return value at index
*/
template<typename T>
T & PTensor<T>::getValue(size_t indexRow, size_t indexCol){
	return getValue(indexRow*(p_nbCol + p_padding) + indexCol);
}

///Copy function of PTensor
/**	@param other : class to copy
*/
template<typename T>
void PTensor<T>::copyPTensor(const PTensor<T> & other){
	p_isAligned = other.p_isAligned;
	p_allocMode = other.p_allocMode;
	p_nbNeighbour = other.p_nbNeighbour;
	p_nbScalRow = other.p_nbScalRow;
	p_isOwnData = other.p_isOwnData;
	if(p_isOwnData){
		reserve(other.p_reservedShape, other.p_reservedNbDimension);
		resize(other.p_shape, other.p_nbDimension);
		for(size_t i(0lu); i < p_fullSize; ++i){
			p_tabData[i] = other.p_tabData[i];
		}
	}else{
		p_reservedShape = other.p_reservedShape;
		p_reservedNbDimension = other.p_reservedNbDimension;
		p_shape = other.p_shape;
		p_nbDimension = other.p_nbDimension;

		p_fullSize = other.p_fullSize;
		p_tabData = other.p_tabData;

		p_padding = other.p_padding;
		p_fullPaddedSize = other.p_fullPaddedSize;
		p_nbCol = other.p_nbCol;
		p_fullNbRow = other.p_fullNbRow;
	}
}

///Initialisation function of the class PTensor
/**	@param allocMode : allocation mode (AllocMode::NONE, AllocMode::ALIGNED, AllocMode::PADDING)
 * 	@param tabShape : shape of the table to be allocated
 * 	@param nbDim : number of dimensions of the PTensor
*/
template<typename T>
void PTensor<T>::initialisationPTensor(AllocMode::AllocMode allocMode, const size_t * tabShape, size_t nbDim){
	p_tabData = NULL;
	p_shape = NULL;
	p_nbDimension = 0lu;
	p_reservedShape = NULL;
	p_reservedNbDimension = 0lu;
	p_padding = 0lu;
	p_isAligned = false;
	p_allocMode = allocMode;
	p_nbNeighbour = 1lu;
	p_nbScalRow = 0lu;
	p_fullSize = 0lu;
	p_fullPaddedSize = 0lu;
	p_nbCol = 0lu;
	p_fullNbRow = 0lu;
	resize(tabShape, nbDim);
}

///Free the table of data
template<typename T>
void PTensor<T>::freeTabData(){
	if(p_tabData == NULL || !p_isOwnData){return;}
	if(p_isAligned){freeAlignedVector(p_tabData);}
	else{delete [] p_tabData;}
	p_tabData = NULL;
}

///Copy tensor data into a block
/**	@param[out] block : block to be set
 * 	@param tensorNbCol : number of columns of the tensor
 * 	@param blockSizeRow : current block size rows
 * 	@param blockSizeCol : current block size columns
 * 	@param fullBlockSizeRow : full number of block rows
 * 	@param fullBlockSizeCol : full number of block columns
 * 	@param i : row index of the current block
 * 	@param j : columns index of the current block
 * 	@param neighborRing : number of border ring of padding around a block
*/
template<typename T>
void PTensor<T>::copyTensorToBlock(PBlock<T> & block, size_t tensorNbCol, size_t blockSizeRow, size_t blockSizeCol,
					size_t fullBlockSizeRow, size_t fullBlockSizeCol, size_t i, size_t j, size_t neighborRing) const
{
	block.resize(p_allocMode, blockSizeRow, blockSizeCol);	//Let's resize the block
	block.setNbVecNeighbour(p_nbNeighbour);
	size_t currentBlockIdxRow(i*(fullBlockSizeRow - 2lu*neighborRing));		//Let's determine its location in the main PTensor
	size_t currentBlockIdxCol(j*(fullBlockSizeCol - 2lu*neighborRing*p_nbNeighbour));
	block.setLocation(currentBlockIdxRow, currentBlockIdxCol);

	block_copy_tensorToBlock(block.getData(), blockSizeRow, blockSizeCol, block.getPadding(),
				currentBlockIdxRow, currentBlockIdxCol,
				p_tabData, tensorNbCol, p_padding);
}

///Link tensor data into a block
/**	@param[out] block : block to be set
 * 	@param tensorNbCol : number of columns of the tensor
 * 	@param blockSizeRow : current block size rows
 * 	@param blockSizeCol : current block size columns
 * 	@param fullBlockSizeRow : full number of block rows
 * 	@param fullBlockSizeCol : full number of block columns
 * 	@param i : row index of the current block
 * 	@param j : columns index of the current block
 * 	@param neighborRing : number of border ring of padding around a block
*/
template<typename T>
void PTensor<T>::linkTensorToBlock(PBlock<T> & block, size_t tensorNbCol, size_t blockSizeRow, size_t blockSizeCol,
					size_t fullBlockSizeRow, size_t fullBlockSizeCol, size_t i, size_t j, size_t neighborRing) const
{
	size_t currentBlockIdxRow(i*(fullBlockSizeRow - 2lu*neighborRing));		//Let's determine its location in the main PTensor
	size_t currentBlockIdxCol(j*(fullBlockSizeCol - 2lu*neighborRing*p_nbNeighbour));

	size_t tensorColSize(tensorNbCol + p_padding);
	T * ptrData = p_tabData + currentBlockIdxRow*tensorColSize + currentBlockIdxCol;

	size_t tabDim[] = {blockSizeRow, blockSizeCol};
	size_t blockPadding(tensorColSize - blockSizeCol);
	block.copyPointer(ptrData, tabDim, 2lu, p_isAligned, blockPadding);
	block.setLocation(currentBlockIdxRow, currentBlockIdxCol);
	block.setNbVecNeighbour(p_nbNeighbour);
	block.p_padding = getNbCol() - blockSizeCol;
}

///Compute an update size of given parameters by respect to the block creation
/**	@param[out] nbTotalBlock : total number of blocks
 * 	@param[out] nbInBlockRow : number of inside block on rows
 * 	@param[out] nbInBlockCol : number of inside block on columns
 * 	@param[out] sizeLastInBlockRow : size of the last block on the row
 * 	@param[out] sizeLastInBlockCol : size of the last block on the row
 * 	@param[out] vecBlock : vector of PBlock
 * 	@param blockSizeRow : maximum size of the created block in rows (taking account the neighborRing)
 * 	@param[out] blockSizeCol : maximum size of the created block in columns (taking account the neighborRing) (can be adjusted)
 * 	@param neighborRing : number of border ring to be added around the created blocks
*/
template<typename T>
void PTensor<T>::updateBlockSize(size_t & nbTotalBlock, size_t & nbInBlockRow, size_t & nbInBlockCol,
				size_t & sizeLastInBlockRow, size_t & sizeLastInBlockCol,
				std::vector<PBlock<T> > & vecBlock, size_t blockSizeRow, size_t & blockSizeCol, size_t neighborRing) const
{
	//Modify blockSizeCol if it is not a multiple of the p_nbNeighbour
	if(blockSizeCol % p_nbNeighbour != 0lu){
		size_t nbVecBlock(blockSizeCol/p_nbNeighbour);
		blockSizeCol = nbVecBlock*p_nbNeighbour;
	}
	size_t nbRow(getFullNbRow()), nbCol(getNbCol());

	nbInBlockRow = 0lu;
	sizeLastInBlockRow = 0lu;
	splitBlockSize(nbInBlockRow, sizeLastInBlockRow, blockSizeRow, nbRow, neighborRing, 1lu);
	nbInBlockCol = 0lu;
	sizeLastInBlockCol = 0lu;
	splitBlockSize(nbInBlockCol, sizeLastInBlockCol, blockSizeCol, nbCol, neighborRing, p_nbNeighbour);

	nbTotalBlock = (nbInBlockRow + (sizeLastInBlockRow != 0lu))*(nbInBlockCol + (sizeLastInBlockCol != 0lu));
	if(vecBlock.size() != nbTotalBlock){
		vecBlock.resize(nbTotalBlock);		//Let's resize the vector of blocks
	}
}

///@brief How to write a class in a file
template<typename Stream, typename T>
struct DataStream<Stream, DataStreamMode::WRITE, PTensor<T> >{
	///Get the size of a class PTensor T
	/**	@param[out] ds : stream to write the class PTensor T
	 * 	@param data : data to be saved
	 * 	@return true on success, false otherwise
	*/
	static bool data_stream(Stream & ds, PTensor<T> & data){
		return data.writeStream(ds);
	}
};

///@brief How to read a class in a file
template<typename Stream, typename T>
struct DataStream<Stream, DataStreamMode::READ, PTensor<T> >{
	///Get the size of a class PTensor T
	/**	@param[out] ds : stream to load the class PTensor T
	 * 	@param data : data to be saved
	 * 	@return true on success, false otherwise
	*/
	static bool data_stream(Stream & ds, PTensor<T> & data){
		return data.readStream(ds);
	}
};





#endif




Generated by: GCOVR (Version 4.2)