xref: /external/neven/Embedded/common/src/b_TensorEm/CompactMat.c

/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* ---- includes ----------------------------------------------------------- */

#include "b_TensorEm/CompactMat.h"
#include "b_TensorEm/Functions.h"
#include "b_BasicEm/Math.h"
#include "b_BasicEm/Functions.h"
#include "b_BasicEm/Memory.h"

/* ------------------------------------------------------------------------- */

/* ========================================================================= */
/*                                                                           */
/* ---- \ghd{ auxiliary functions } ---------------------------------------- */
/*                                                                           */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */

/** Returns dot product of inVec with indexed row
    The result is a floating point expresstion:
		upper 16 bit: signed value
		lower 16 bit: signed exponent
 */
int32 bts_CompactMat_fltDotPrdRow( struct bbs_Context* cpA,
								   struct bts_CompactMat* ptrA,
							       const int16* inVecA,
							       uint32 inNormBitsA,
							       uint32 rowA )
{
	const int16* rowPtrL = ptrA->cpsArrE.arrPtrE + ptrA->wordsPerRowE * rowA;

	/* extract row-header info */
	uint32 offsL = *rowPtrL++;
	uint32 sizeL = *rowPtrL++;
	int32 factorManL = *rowPtrL++;
	int32 factorExpL = *rowPtrL++;
	uint32 rowNormBitsL = *rowPtrL++;

	/* consider possible overflow */
	uint16 overflowBitsL = ( inNormBitsA + rowNormBitsL >= 31 ) ? inNormBitsA + rowNormBitsL - 31 : 0;

	const int16* inPtrL = inVecA + offsL;

	count_t iL;
	int32 sumL = 0;

	if( overflowBitsL == 0 ) /* raw dot product fits in int32 */
	{
		switch( ptrA->bitsPerValueE )
		{
			case 16:
			{
				for( iL = sizeL; iL > 0; iL-- ) sumL += ( ( int32 )*rowPtrL++ * ( int32 )*inPtrL++ );
			}
			break;

			#ifndef HW_TMS320C5x /* platforms that don't have int8 must use the 'default' implementation */

			case 8:
			{
				const uint16* dpL = ( uint16* )rowPtrL;
				for( iL = sizeL; iL >= 8; iL -= 8 )
				{
					sumL += ( ( int8 )  dpL[ 0 ]         * ( int32 )inPtrL[ 0 ] );
					sumL += ( ( int8 )( dpL[ 0 ] >>  8 ) * ( int32 )inPtrL[ 1 ] );
					sumL += ( ( int8 )  dpL[ 1 ]         * ( int32 )inPtrL[ 2 ] );
					sumL += ( ( int8 )( dpL[ 1 ] >>  8 ) * ( int32 )inPtrL[ 3 ] );
					sumL += ( ( int8 )  dpL[ 2 ]         * ( int32 )inPtrL[ 4 ] );
					sumL += ( ( int8 )( dpL[ 2 ] >>  8 ) * ( int32 )inPtrL[ 5 ] );
					sumL += ( ( int8 )  dpL[ 3 ]         * ( int32 )inPtrL[ 6 ] );
					sumL += ( ( int8 )( dpL[ 3 ] >>  8 ) * ( int32 )inPtrL[ 7 ] );
					dpL += 4;
					inPtrL += 8;
				}
				for( ; iL >= 2; iL -= 2 )
				{
					sumL += ( ( int8 )  *dpL         * ( int32 )inPtrL[ 0 ] );
					sumL += ( ( int8 )( *dpL >>  8 ) * ( int32 )inPtrL[ 1 ] );
					dpL++;
					inPtrL += 2;
				}
				if( iL > 0 )
				{
					sumL += ( ( int8 )*dpL++ * ( int32 )inPtrL[ 0 ] );
				}
			}
			break;

			case 6:
			{
				const uint16* dpL = ( uint16* )rowPtrL;
				for( iL = sizeL; iL >= 8; iL -= 8 )
				{
					int32 lSumL = 0;
					lSumL += ( ( int8 )     ( dpL[ 0 ] <<  2 )                                  * ( int32 )inPtrL[ 0 ] );
					lSumL += ( ( int8 ) (   ( dpL[ 0 ] >>  4 )                       & 0x00FC ) * ( int32 )inPtrL[ 1 ] );
					lSumL += ( ( int8 ) ( ( ( dpL[ 0 ] >> 10 ) | ( dpL[ 1 ] << 6 ) ) & 0x00FC ) * ( int32 )inPtrL[ 2 ] );
					lSumL += ( ( int8 ) (   ( dpL[ 1 ]       )                       & 0x00FC ) * ( int32 )inPtrL[ 3 ] );
					lSumL += ( ( int8 ) (   ( dpL[ 1 ] >>  6 )                       & 0x00FC ) * ( int32 )inPtrL[ 4 ] );
					lSumL += ( ( int8 ) ( ( ( dpL[ 1 ] >> 12 ) | ( dpL[ 2 ] << 4 ) ) & 0x00FC ) * ( int32 )inPtrL[ 5 ] );
					lSumL += ( ( int8 ) (   ( dpL[ 2 ] >>  2 )                       & 0x00FC ) * ( int32 )inPtrL[ 6 ] );
					lSumL += ( ( int8 ) (   ( dpL[ 2 ] >>  8 )                       & 0x00FC ) * ( int32 )inPtrL[ 7 ] );
					sumL += ( lSumL >> 2 );
					dpL += 3;
					inPtrL += 8;
				}

				{
					int32 lSumL = 0;
					if( iL > 0 ) lSumL += ( ( int8 )     ( dpL[ 0 ] <<  2 )                                  * ( int32 )inPtrL[ 0 ] );
					if( iL > 1 ) lSumL += ( ( int8 ) (   ( dpL[ 0 ] >>  4 )                       & 0x00FC ) * ( int32 )inPtrL[ 1 ] );
					if( iL > 2 ) lSumL += ( ( int8 ) ( ( ( dpL[ 0 ] >> 10 ) | ( dpL[ 1 ] << 6 ) ) & 0x00FC ) * ( int32 )inPtrL[ 2 ] );
					if( iL > 3 ) lSumL += ( ( int8 ) (   ( dpL[ 1 ]       )                       & 0x00FC ) * ( int32 )inPtrL[ 3 ] );
					if( iL > 4 ) lSumL += ( ( int8 ) (   ( dpL[ 1 ] >>  6 )                       & 0x00FC ) * ( int32 )inPtrL[ 4 ] );
					if( iL > 5 ) lSumL += ( ( int8 ) ( ( ( dpL[ 1 ] >> 12 ) | ( dpL[ 2 ] << 4 ) ) & 0x00FC ) * ( int32 )inPtrL[ 5 ] );
					if( iL > 6 ) lSumL += ( ( int8 ) (   ( dpL[ 2 ] >>  2 )                       & 0x00FC ) * ( int32 )inPtrL[ 6 ] );
					sumL += ( lSumL >> 2 );
				}
			}
			break;

			case 5:
			{
				const uint16* dpL = ( uint16* )rowPtrL;
				for( iL = sizeL; iL >= 16; iL -= 16 )
				{
					int32 lSumL = 0;
					lSumL += ( ( int8 )     ( dpL[ 0 ] <<  3 )                                  * ( int32 )inPtrL[  0 ] );
					lSumL += ( ( int8 ) (   ( dpL[ 0 ] >>  2 )                       & 0x00F8 ) * ( int32 )inPtrL[  1 ] );
					lSumL += ( ( int8 ) (   ( dpL[ 0 ] >>  7 )                       & 0x00F8 ) * ( int32 )inPtrL[  2 ] );
					lSumL += ( ( int8 ) ( ( ( dpL[ 0 ] >> 12 ) | ( dpL[ 1 ] << 4 ) ) & 0x00F8 ) * ( int32 )inPtrL[  3 ] );
					lSumL += ( ( int8 ) (   ( dpL[ 1 ] >>  1 )                       & 0x00F8 ) * ( int32 )inPtrL[  4 ] );
					lSumL += ( ( int8 ) (   ( dpL[ 1 ] >>  6 )                       & 0x00F8 ) * ( int32 )inPtrL[  5 ] );
					lSumL += ( ( int8 ) ( ( ( dpL[ 1 ] >> 11 ) | ( dpL[ 2 ] << 5 ) ) & 0x00F8 ) * ( int32 )inPtrL[  6 ] );
					lSumL += ( ( int8 ) (   ( dpL[ 2 ]       )                       & 0x00F8 ) * ( int32 )inPtrL[  7 ] );
					lSumL += ( ( int8 ) (   ( dpL[ 2 ] >>  5 )                       & 0x00F8 ) * ( int32 )inPtrL[  8 ] );
					lSumL += ( ( int8 ) ( ( ( dpL[ 2 ] >> 10 ) | ( dpL[ 3 ] << 6 ) ) & 0x00F8 ) * ( int32 )inPtrL[  9 ] );
					lSumL += ( ( int8 ) (   ( dpL[ 3 ] <<  1 )                       & 0x00F8 ) * ( int32 )inPtrL[ 10 ] );
					lSumL += ( ( int8 ) (   ( dpL[ 3 ] >>  4 )                       & 0x00F8 ) * ( int32 )inPtrL[ 11 ] );
					lSumL += ( ( int8 ) ( ( ( dpL[ 3 ] >>  9 ) | ( dpL[ 4 ] << 7 ) ) & 0x00F8 ) * ( int32 )inPtrL[ 12 ] );
					lSumL += ( ( int8 ) (   ( dpL[ 4 ] <<  2 )                       & 0x00F8 ) * ( int32 )inPtrL[ 13 ] );
					lSumL += ( ( int8 ) (   ( dpL[ 4 ] >>  3 )                       & 0x00F8 ) * ( int32 )inPtrL[ 14 ] );
					lSumL += ( ( int8 ) (   ( dpL[ 4 ] >>  8 )                       & 0x00F8 ) * ( int32 )inPtrL[ 15 ] );
					sumL += ( lSumL >> 3 );
					dpL += 5;
					inPtrL += 16;
				}

				{
					int32 lSumL = 0;
					if( iL >  0 ) lSumL += ( ( int8 )     ( dpL[ 0 ] <<  3 )                                  * ( int32 )inPtrL[  0 ] );
					if( iL >  1 ) lSumL += ( ( int8 ) (   ( dpL[ 0 ] >>  2 )                       & 0x00F8 ) * ( int32 )inPtrL[  1 ] );
					if( iL >  2 ) lSumL += ( ( int8 ) (   ( dpL[ 0 ] >>  7 )                       & 0x00F8 ) * ( int32 )inPtrL[  2 ] );
					if( iL >  3 ) lSumL += ( ( int8 ) ( ( ( dpL[ 0 ] >> 12 ) | ( dpL[ 1 ] << 4 ) ) & 0x00F8 ) * ( int32 )inPtrL[  3 ] );
					if( iL >  4 ) lSumL += ( ( int8 ) (   ( dpL[ 1 ] >>  1 )                       & 0x00F8 ) * ( int32 )inPtrL[  4 ] );
					if( iL >  5 ) lSumL += ( ( int8 ) (   ( dpL[ 1 ] >>  6 )                       & 0x00F8 ) * ( int32 )inPtrL[  5 ] );
					if( iL >  6 ) lSumL += ( ( int8 ) ( ( ( dpL[ 1 ] >> 11 ) | ( dpL[ 2 ] << 5 ) ) & 0x00F8 ) * ( int32 )inPtrL[  6 ] );
					if( iL >  7 ) lSumL += ( ( int8 ) (   ( dpL[ 2 ]       )                       & 0x00F8 ) * ( int32 )inPtrL[  7 ] );
					if( iL >  8 ) lSumL += ( ( int8 ) (   ( dpL[ 2 ] >>  5 )                       & 0x00F8 ) * ( int32 )inPtrL[  8 ] );
					if( iL >  9 ) lSumL += ( ( int8 ) ( ( ( dpL[ 2 ] >> 10 ) | ( dpL[ 3 ] << 6 ) ) & 0x00F8 ) * ( int32 )inPtrL[  9 ] );
					if( iL > 10 ) lSumL += ( ( int8 ) (   ( dpL[ 3 ] <<  1 )                       & 0x00F8 ) * ( int32 )inPtrL[ 10 ] );
					if( iL > 11 ) lSumL += ( ( int8 ) (   ( dpL[ 3 ] >>  4 )                       & 0x00F8 ) * ( int32 )inPtrL[ 11 ] );
					if( iL > 12 ) lSumL += ( ( int8 ) ( ( ( dpL[ 3 ] >>  9 ) | ( dpL[ 4 ] << 7 ) ) & 0x00F8 ) * ( int32 )inPtrL[ 12 ] );
					if( iL > 13 ) lSumL += ( ( int8 ) (   ( dpL[ 4 ] <<  2 )                       & 0x00F8 ) * ( int32 )inPtrL[ 13 ] );
					if( iL > 14 ) lSumL += ( ( int8 ) (   ( dpL[ 4 ] >>  3 )                       & 0x00F8 ) * ( int32 )inPtrL[ 14 ] );
					sumL += ( lSumL >> 3 );
				}
			}
			break;

			case 4:
			{
				for( iL = sizeL; iL >= 4; iL -= 4 )
				{
					uint16 v1L = *rowPtrL++;
					int32 lSumL = 0;
					lSumL += ( ( int8 )( ( v1L << 4 )        ) * ( int32 )inPtrL[ 0 ] );
					lSumL += ( ( int8 )( ( v1L      ) & 0xF0 ) * ( int32 )inPtrL[ 1 ] );
					lSumL += ( ( int8 )( ( v1L >> 4 ) & 0xF0 ) * ( int32 )inPtrL[ 2 ] );
					lSumL += ( ( int8 )( ( v1L >> 8 ) & 0xF0 ) * ( int32 )inPtrL[ 3 ] );
					inPtrL += 4;
					sumL += ( lSumL >> 4 );
				}
				{
					uint16 v1L = *rowPtrL++;
					int32 lSumL = 0;
					if( iL-- > 0 ) lSumL += ( ( int8 )( ( v1L << 4 )        ) * ( int32 )inPtrL[ 0 ] );
					if( iL-- > 0 ) lSumL += ( ( int8 )( ( v1L      ) & 0xF0 ) * ( int32 )inPtrL[ 1 ] );
					if( iL-- > 0 ) lSumL += ( ( int8 )( ( v1L >> 4 ) & 0xF0 ) * ( int32 )inPtrL[ 2 ] );
					sumL += ( lSumL >> 4 );
				}
			}
			break;

			#endif /*ifndef HW_TMS320C5x*/

			/* The default case can process all bit sizes including those that are explicitly encoded above
			 * Use the default for all bit sizes when the platform cannot handle the int8 data type (e.g. HW_TMS320C5x)
			 */
			default:
			{
				uint32 bfL = ( ( uint32 )*rowPtrL++ ) << 16;
				uint32 bitsL = ptrA->bitsPerValueE;
				uint16 adjL = 16 - bitsL;
				uint32 mkL = ( ( 1 << bitsL ) - 1 ) << adjL;
				uint32 srL = bitsL;
				for( iL = 0; iL < sizeL; iL++ )
				{
					if( srL > 16 )
					{
						bfL = ( ( ( uint32 )*rowPtrL++ ) << 16 ) | ( bfL >> 16 );
						srL -= 16;
					}
					sumL += ( ( int16 )( ( bfL >> srL ) & mkL ) * ( int32 )inPtrL[ iL ] ) >> adjL;
					srL += bitsL;
				}
			}
		}
	}
	else /* raw dot product does not fit in int32 */
	{
		int32 roundL = 1 << ( overflowBitsL - 1 );
		switch( ptrA->bitsPerValueE )
		{
			case 16:
			{
				for( iL = sizeL; iL > 0; iL-- ) sumL += ( ( ( int32 )*rowPtrL++ * ( int32 )*inPtrL++ ) + roundL ) >> overflowBitsL;
			}
			break;

			case 8:
			{
				for( iL = sizeL; iL >= 2; iL -= 2 )
				{
					uint16 v1L = *rowPtrL++;
					int32 lSumL =   ( ( int8 )  v1L         * ( int32 )inPtrL[ 0 ] )
						          + ( ( int8 )( v1L >>  8 ) * ( int32 )inPtrL[ 1 ] );
					sumL += ( lSumL + roundL ) >> overflowBitsL;
					inPtrL += 2;
				}
				if( iL > 0 )
				{
					sumL += ( ( ( int8 )*rowPtrL++ * ( int32 )inPtrL[ 0 ] ) + roundL ) >> overflowBitsL;
				}
			}
			break;

			case 4:
			{
				for( iL = sizeL; iL >= 4; iL -= 4 )
				{
					uint16 v1L = *rowPtrL++;
					int32 lSumL = 0;
					lSumL += ( ( int8 )( ( v1L << 4 )        ) * ( int32 )inPtrL[ 0 ] );
					lSumL += ( ( int8 )( ( v1L      ) & 0xF0 ) * ( int32 )inPtrL[ 1 ] );
					lSumL += ( ( int8 )( ( v1L >> 4 ) & 0xF0 ) * ( int32 )inPtrL[ 2 ] );
					lSumL += ( ( int8 )( ( v1L >> 8 ) & 0xF0 ) * ( int32 )inPtrL[ 3 ] );
					inPtrL += 4;
					sumL += ( ( lSumL >> 4 ) + roundL ) >> overflowBitsL;
				}
				{
					uint16 v1L = *rowPtrL++;
					int32 lSumL = 0;
					if( iL-- > 0 ) lSumL += ( ( int8 )( ( v1L << 4 )        ) * ( int32 )inPtrL[ 0 ] );
					if( iL-- > 0 ) lSumL += ( ( int8 )( ( v1L      ) & 0xF0 ) * ( int32 )inPtrL[ 1 ] );
					if( iL-- > 0 ) lSumL += ( ( int8 )( ( v1L >> 4 ) & 0xF0 ) * ( int32 )inPtrL[ 2 ] );
					sumL += ( ( lSumL >> 4 ) + roundL ) >> overflowBitsL;
				}
			}
			break;

			default:
			{
				uint32 bfL = ( ( uint32 )*rowPtrL++ ) << 16;
				uint32 bitsL = ptrA->bitsPerValueE;
				uint16 adjL = 16 - bitsL;
				uint32 mkL = ( ( 1 << bitsL ) - 1 ) << adjL;
				uint32 srL = bitsL;
				int32 lRoundL = roundL << adjL;
				int32 lAdjL = overflowBitsL + adjL;
				for( iL = 0; iL < sizeL; iL++ )
				{
					if( srL > 16 )
					{
						bfL = ( ( ( uint32 )*rowPtrL++ ) << 16 ) | ( bfL >> 16 );
						srL -= 16;
					}
					sumL += ( ( int16 )( ( bfL >> srL ) & mkL ) * ( int32 )inPtrL[ iL ] + lRoundL ) >> lAdjL;
					srL += bitsL;
				}
			}
		}
	}

	/* compute result */
	{
		int32 resultManL;
		int32 resultExpL;
		int32 resultLogL;
		bbs_mulS32( sumL, factorManL, &resultManL, &resultExpL );
		resultExpL += factorExpL + overflowBitsL;
		resultLogL = bbs_intLog2( resultManL > 0 ? resultManL : -resultManL );
		if( resultLogL < 30 )
		{
			resultManL <<= 30 - resultLogL;
			resultExpL  -= 30 - resultLogL;
		}

		resultManL = ( ( resultManL >> 15 ) + 1 ) >> 1;
		resultExpL = resultExpL + 16;

		return ( ( resultManL & 0x0000FFFF ) << 16 ) | ( resultExpL & 0x0000FFFF );
	}
}

/* ------------------------------------------------------------------------- */

/* ========================================================================= */
/*                                                                           */
/* ---- \ghd{ constructor / destructor } ----------------------------------- */
/*                                                                           */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */

void bts_CompactMat_init( struct bbs_Context* cpA,
					      struct bts_CompactMat* ptrA )
{
	ptrA->widthE = 0;
	ptrA->heightE = 0;
	ptrA->bitsPerValueE = 0;
	ptrA->wordsPerRowE = 0;
	ptrA->maxRowBitsE = 0;
	bbs_Int16Arr_init( cpA, &ptrA->cpsArrE );
	bbs_Int16Arr_init( cpA, &ptrA->expArrE );

}

/* ------------------------------------------------------------------------- */

void bts_CompactMat_exit( struct bbs_Context* cpA,
					    struct bts_CompactMat* ptrA )
{
	ptrA->widthE = 0;
	ptrA->heightE = 0;
	ptrA->bitsPerValueE = 0;
	ptrA->wordsPerRowE = 0;
	ptrA->maxRowBitsE = 0;
	bbs_Int16Arr_exit( cpA, &ptrA->cpsArrE );
	bbs_Int16Arr_exit( cpA, &ptrA->expArrE );
}
/* ------------------------------------------------------------------------- */

/* ========================================================================= */
/*                                                                           */
/* ---- \ghd{ operators } -------------------------------------------------- */
/*                                                                           */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */

/* ========================================================================= */
/*                                                                           */
/* ---- \ghd{ query functions } -------------------------------------------- */
/*                                                                           */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */

/* ========================================================================= */
/*                                                                           */
/* ---- \ghd{ modify functions } ------------------------------------------- */
/*                                                                           */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */

void bts_CompactMat_create( struct bbs_Context* cpA,
						    struct bts_CompactMat* ptrA,
						    uint32 widthA,
						    uint32 heightA,
						    uint32 bitsA,
							uint32 maxRowSizeA,
				            struct bbs_MemSeg* mspA )
{
	if( bbs_Context_error( cpA ) ) return;
	if( bitsA < 2 || bitsA > 16 )
	{
		bbs_ERROR0( "bts_CompactMat_create:\nbitsA must be between 2 and 16" );
		return;
	}

	ptrA->widthE = widthA;
	ptrA->heightE = heightA;
	ptrA->bitsPerValueE = bitsA;
	ptrA->wordsPerRowE = 6 /*header + 1*/ + ( ( maxRowSizeA * bitsA ) / ( 8 * sizeof( short ) ) );
	ptrA->maxRowBitsE = 0;
	if( ( ptrA->wordsPerRowE & 1 ) != 0 ) ptrA->wordsPerRowE++;
	bbs_Int16Arr_create( cpA, &ptrA->cpsArrE, heightA * ptrA->wordsPerRowE, mspA );
	bbs_Int16Arr_fill( cpA, &ptrA->cpsArrE, 0 );
	bbs_Int16Arr_create( cpA, &ptrA->expArrE, ptrA->heightE, mspA );
	bbs_Int16Arr_fill( cpA, &ptrA->expArrE, 0 );
}

/* ------------------------------------------------------------------------- */

void bts_CompactMat_copy( struct bbs_Context* cpA,
					      struct bts_CompactMat* ptrA,
						  const struct bts_CompactMat* srcPtrA )
{
	ptrA->widthE = srcPtrA->widthE;
	ptrA->heightE = srcPtrA->heightE;
	ptrA->bitsPerValueE = srcPtrA->bitsPerValueE;
	ptrA->wordsPerRowE = srcPtrA->wordsPerRowE;
	ptrA->maxRowBitsE = srcPtrA->maxRowBitsE;
	bbs_Int16Arr_copy( cpA, &ptrA->cpsArrE, &srcPtrA->cpsArrE );
	bbs_Int16Arr_size( cpA, &ptrA->expArrE, ptrA->heightE );
}

/* ------------------------------------------------------------------------- */

/* ========================================================================= */
/*                                                                           */
/* ---- \ghd{ I/O } -------------------------------------------------------- */
/*                                                                           */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */

uint32 bts_CompactMat_memSize( struct bbs_Context* cpA,
							 const struct bts_CompactMat *ptrA )
{
	return  bbs_SIZEOF16( uint32 )
		  + bbs_SIZEOF16( uint32 ) /* version */
		  + bbs_SIZEOF16( ptrA->widthE )
		  + bbs_SIZEOF16( ptrA->heightE )
		  + bbs_SIZEOF16( ptrA->bitsPerValueE )
		  + bbs_SIZEOF16( ptrA->wordsPerRowE )
		  + bbs_SIZEOF16( ptrA->maxRowBitsE )
		  + bbs_Int16Arr_memSize( cpA, &ptrA->cpsArrE );
}

/* ------------------------------------------------------------------------- */

uint32 bts_CompactMat_memWrite( struct bbs_Context* cpA,
							  const struct bts_CompactMat* ptrA,
							  uint16* memPtrA )
{
	uint32 memSizeL = bts_CompactMat_memSize( cpA, ptrA );
	memPtrA += bbs_memWrite32( &memSizeL, memPtrA );
	memPtrA += bbs_memWriteUInt32( bts_COMPACT_MAT_VERSION, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->widthE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->heightE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->bitsPerValueE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->wordsPerRowE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->maxRowBitsE, memPtrA );
	memPtrA += bbs_Int16Arr_memWrite( cpA, &ptrA->cpsArrE, memPtrA );
	return memSizeL;
}

/* ------------------------------------------------------------------------- */

uint32 bts_CompactMat_memRead( struct bbs_Context* cpA,
							 struct bts_CompactMat* ptrA,
							 const uint16* memPtrA,
				             struct bbs_MemSeg* mspA )
{
	uint32 memSizeL, versionL;
	if( bbs_Context_error( cpA ) ) return 0;
	memPtrA += bbs_memRead32( &memSizeL, memPtrA );
	memPtrA += bbs_memReadVersion32( cpA, &versionL, bts_COMPACT_MAT_VERSION, memPtrA );
	memPtrA += bbs_memRead32( &ptrA->widthE, memPtrA );
	memPtrA += bbs_memRead32( &ptrA->heightE, memPtrA );
	memPtrA += bbs_memRead32( &ptrA->bitsPerValueE, memPtrA );
	memPtrA += bbs_memRead32( &ptrA->wordsPerRowE, memPtrA );
	memPtrA += bbs_memRead32( &ptrA->maxRowBitsE, memPtrA );
	memPtrA += bbs_Int16Arr_memRead( cpA, &ptrA->cpsArrE, memPtrA, mspA );

	if( memSizeL != bts_CompactMat_memSize( cpA, ptrA ) )
	{
		bbs_ERR0( bbs_ERR_CORRUPT_DATA, "uint32 bts_CompactMat_memRead( const struct bts_CompactMat* ptrA, const void* memPtrA ):\n"
                  "size mismatch" );
	}

	bbs_Int16Arr_create( cpA, &ptrA->expArrE, ptrA->heightE, mspA );
	bbs_Int16Arr_fill( cpA, &ptrA->expArrE, 0 );

	return memSizeL;
}

/* ------------------------------------------------------------------------- */

/* ========================================================================= */
/*                                                                           */
/* ---- \ghd{ exec functions } --------------------------------------------- */
/*                                                                           */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */

void bts_CompactMat_map( struct bbs_Context* cpA,
						 const struct bts_CompactMat* ptrA,
						 const int16* inVecA,
						 int16* outVecA,
						 int16* outExpPtrA )
{
	uint32 inNormBitsL = bbs_intLog2( bbs_vecNorm16( inVecA, ptrA->widthE ) ) + 1;
	uint32 iL;

	int16* expArrL = ( ( struct bts_CompactMat* )ptrA )->expArrE.arrPtrE;
	int16 maxExpL = -32767;

	for( iL = 0; iL < ptrA->heightE; iL++ )
	{
		int32 fltL = bts_CompactMat_fltDotPrdRow( cpA, ( struct bts_CompactMat* )ptrA, inVecA, inNormBitsL, iL );
		outVecA[ iL ] = fltL >> 16;
		expArrL[ iL ] = fltL & 0x0000FFFF;

		maxExpL = ( expArrL[ iL ] > maxExpL ) ? expArrL[ iL ] : maxExpL;
	}

	if( outExpPtrA != NULL ) *outExpPtrA = maxExpL;

	for( iL = 0; iL < ptrA->heightE; iL++ )
	{
		int32 shrL = maxExpL - expArrL[ iL ];
		if( shrL > 0 )
		{
			outVecA[ iL ] = ( ( outVecA[ iL ] >> ( shrL - 1 ) ) + 1 ) >> 1;
		}
	}
}

/* ------------------------------------------------------------------------- */

/* ========================================================================= */