|
|
//+-------------------------------------------------------------------------
//
// Microsoft Windows
//
// Copyright (C) Microsoft Corporation, 1997 - 1998
//
// File: mdvect.h
//
//--------------------------------------------------------------------------
//
// mdvect.h: multi-dimensional array handling
//
#ifndef _MDVECT_H_
#define _MDVECT_H_
/*
Multidimensional array classes and templates.
Each array carries the dimensionality of each dimension as a short integer; the signed value is reinterpreted for projections and redimensioning.
Note that giving a subscript array (VIMD) whose length is less than the dimensionality of the target array produces a subscript with lower dimensions assumed to be equal to zero. This is useful for indexing to lowest-dimensioned rows for probability tables.
Types used (see basics.h):
REAL is a double VLREAL is valarray<REAL> IMD is an unsigned index into a multi-dimensional array VIMD is a vector of IMD SIMD is a signed index into a multi-dimensional array; it's used for projecting dimensions out VSIMD is a vector of SIMD
An MDVSLICE is dimensionality and iteration information for an m-d vector or maxtrix.
The template TMDVDENSE defines a generic multi-dimensional array which a pair of elements: 'first' is a flat (1-d) valarray of an unspecified type (e.g., REAL) 'second' is an MDVSLICE describing its dimensionality
The nested class TMDVDENSE::Iterator (note the capital 'I') is the smart iterator for classes derived from TMDVDENSE<>. */
#include <stdarg.h>
#include "algos.h"
typedef valarray<REAL> VLREAL;
// 'valarray' comparison templates
template<class _V>struct lessv : binary_function<_V, _V, bool>{ bool operator()(const _V & vra, const _V & vrb) const { int cmin = _cpp_min( vra.size(), vrb.size() ); for ( int i = 0 ; i < cmin ; i++ ) { if ( vra[i] < vrb[i] ) return true; if ( vra[i] > vrb[i] ) return false; } return vra.size() < vrb.size(); }};
/////////////////////////////////////////////////////////////////////////////////
// Class MDVSLICE:
// Similar to 'gslice'. Has gslice converter (see 'valarray' header).
// Contains integer array of lengths, array of strides
// and starting point.
/////////////////////////////////////////////////////////////////////////////////
class MDVSLICE{ public: // Construct a slice from complete data (like gslice)
MDVSLICE ( size_t _S, const VIMD & _L, const VIMD & _D) : _Start(_S), _Len(_L), _Stride(_D) {}
// Construct a slice given only the dimensions
MDVSLICE ( const VIMD & _L, size_t _S = 0 ) { Init( _L, _S ); } MDVSLICE ( int cdim, int ibound, ... ) : _Start(0) { va_list vl; va_start( vl, cdim ); Init( cdim, vl ); }
MDVSLICE ( const VSIMD & vsimd, size_t _S = 0 ) { Init( vsimd, _S ); }
bool operator == ( const MDVSLICE & sl ) const { return _Start == sl._Start && vequal(_Len,sl._Len) && vequal(_Stride,sl._Stride); } bool operator != ( const MDVSLICE & sl ) const { return !(*this == sl); }
// Provided for compatibility with gslice
MDVSLICE() : _Start(0) {}
// Return an equivalent gslice for use with other 'valarray' operations
gslice Gslice () const;
void Init ( const VIMD & _L, size_t _S = 0 ) { _Start = _S; _Len = _L; StrideFromLength(); }
void Init ( const VSIMD & vsimd, size_t _S = 0 ) { int cd = vsimd.size(); vbool vboolMissing(cd); _Len.resize(cd); _Start = _S; for ( int i = 0; i < cd; i++ ) { SIMD simd = vsimd[i]; if ( vboolMissing[i] = simd < 0 ) _Len[i] = - simd; else _Len[i] = simd; } StrideFromLength( & vboolMissing ); }
void Init ( int cdim, ... ) { va_list vl; va_start( vl, cdim ); Init( cdim, vl ); }
void Init ( int cdim, va_list & vl ) { _Len.resize(cdim); for ( int idim = 0; idim < cdim; idim++ ) { _Len[idim] = va_arg(vl,int); } StrideFromLength(); }
/********************************************************
* Accessors to internal data *********************************************************/ size_t start() const {return _Start; } const VIMD & size() const {return _Len; } const VIMD & stride() const {return _Stride; } // Return the number of dimensions
size_t _Nslice() const { return _Len.size(); }
// Return the total number of elements according to this slice
size_t _Totlen() const { size_t _L = _Len.size() > 0; if ( _L ) { for (size_t _I = 0; _I < _Len.size(); ++_I ) { if ( _Len[_I] ) _L *= _Len[_I]; } } return _L; }
/********************************************************
* Subscript handling. There are two levels, one leaves * the subscript array unchanged, the other updates it. * There is a set of overloads for these which allow * reordering of dimensions. *********************************************************/
// Return the index offset based upon the subscript array given
size_t _IOff ( const VIMD& _Idx ) const { size_t _K = _Start; for (size_t _I = 0; _I < _Idx.size(); ++_I) _K += _Idx[_I] * _Stride[_I]; return _K; } // Return the index offset based upon the varargs array given
size_t _IOff ( int i, ... ) const { va_list vl; va_start( vl, i ); return _IOff( i, vl ); } size_t _IOff ( int i, va_list & vl ) const { size_t ioff = _Start; int j; for ( j = 0; j < _Len.size() && i >= 0 ; ++j ) { ioff += i * _Stride[j]; i = va_arg(vl,int); } return j == _Len.size() ? ioff : -1; } // Bump the subscript array to its next valid index
void _Upd (VIMD & _Idx) const { for (size_t _I = _Len.size(); 0 < _I--;) { if (++_Idx[_I] < _Len[_I]) break; _Idx[_I] = 0; } }
// Iterate to the next subscript by computing its offset and updating
// THIS IS THE FUNCTION USED FOR NORMAL ITERATION
size_t _Off (VIMD& _Idx) const { size_t _K = _IOff(_Idx); _Upd(_Idx); return _K; }
// Dimension reordering overloads; each behaves identically to its
// base function, but accepts a dimension reordering array
size_t _IOff(const VIMD& _Idx, const VIMD& _Idim) const { size_t _K = _Start; for (size_t _I = 0; _I < _Idx.size(); ++_I) { size_t _II = _Idim[_I]; _K += _Idx[_II] * _Stride[_II]; } return _K; } void _Upd (VIMD & _Idx, const VIMD& _Idim) const { for (size_t _I = _Len.size(); 0 < _I--;) { size_t _II = _Idim[_I]; if (++_Idx[_II] < _Len[_II]) break; _Idx[_II] = 0; } }
size_t _Off (VIMD& _Idx, const VIMD& _Idim) const { size_t _K = _IOff(_Idx,_Idim); _Upd(_Idx,_Idim); return _K; }
// Return an array like (0,1,2,3,...) for use with
// the dimension-reordering members above
void InitDimReorder ( VIMD & vimdDim ) const { vimdDim.resize( _Nslice() ); for ( size_t i = 0 ; i < vimdDim.size() ; ++i ) { vimdDim[i] = i; } } protected: size_t _Start; // Absolute starting offset into array
VIMD _Len; // Signed integer array of dimension lengths
VIMD _Stride; // Signed integer array of strides
// Given the dimension lengths, compute the array of strides.
inline void StrideFromLength ( const vbool * pvboolMissing = NULL );};
/////////////////////////////////////////////////////////////////////////////////
//
// Template TMDVDENSE: Generalized multidimensional array handling.
// Base class is 'valarray', so member elements must be available
// (directly or through conversion) for mathematical operations.
// For example, there's a "sum()" member for valarrays.
//
/////////////////////////////////////////////////////////////////////////////////
template<class T>class TMDVDENSE : public pair<valarray<T>,MDVSLICE>{ typedef valarray<T> vr_base; typedef pair<valarray<T>,MDVSLICE> pair_base;
public: TMDVDENSE ( const VIMD & vimd ) : pair_base( vr_base(), vimd ) { SyncSize(); } TMDVDENSE () {} ~ TMDVDENSE () {} void Init ( const VIMD & vimd, size_t start = 0 ) { second.Init( vimd, start ); SyncSize(); }
void Init ( const MDVSLICE & mdvs ) { second = mdvs; SyncSize(); } void Init ( int cdim, ... ) { va_list vl; va_start( vl, cdim ); Init( cdim, vl ); }
void Init ( int cdim, va_list & vl ) { second.Init( cdim, vl ); SyncSize(); }
void SyncSize () { size_t cElem = second._Totlen(); if ( first.size() != cElem ) first.resize( cElem ); }
// Subscripting as flat array
T & operator [] ( int i ) { return first.operator[](i); } T operator [] ( int i ) const { return first.operator[](i); }
// Subscripting as m-d array
T & operator [] ( const VIMD & vimd ) { return (*this)[ second._IOff(vimd) ]; } T operator [] ( const VIMD & vimd ) const { return (*this)[ second._IOff(vimd) ]; }
size_t size () const { return first.size(); }
const MDVSLICE & Slice () const { return second ; }
const VIMD & VimdDim () const { return second.size(); }
bool operator == ( const TMDVDENSE & mdv ) const { return vequal(first,mdv.first) && second == mdv.second; } bool operator != ( const TMDVDENSE & mdv ) const { return !(*this == mdv); }
class Iterator { public: Iterator ( TMDVDENSE & mdv ) : _mdv(mdv), _mdvSlice( mdv.Slice() ), _itcurr(0), _itend( mdv.size() ), _bDimReorder(false) { assert( _mdvSlice._Totlen() == _itend ); _vimd.resize(_mdvSlice._Nslice()); }
Iterator ( TMDVDENSE & mdv, const MDVSLICE & mdvslice ) : _mdv(mdv), _mdvSlice( mdvslice ), _itcurr(0), _itend( mdvslice._Totlen() ), _bDimReorder(false) { _vimd.resize(_mdvSlice._Nslice()); }
void Reset() { vclear( _vimd, 0 ); _itcurr = 0; }
// Return flat index given const subscript array
size_t Indx ( const VIMD & vimd ) const { return _bDimReorder ? _mdvSlice._IOff( vimd, _vimdDim ) : _mdvSlice._IOff( vimd ); } // Return flat index given subscript array; update sub array
size_t IndxUpd ( VIMD & vimd ) { return _bDimReorder ? _mdvSlice._Off( vimd, _vimdDim ) : _mdvSlice._Off( vimd ); } // Return current flat index, no update
size_t Indx () const { return Indx( _vimd ); } // Return current flat index, with update
size_t IndxUpd () { if ( _itcurr < _itend ) _itcurr++; return IndxUpd( _vimd ); } // Return current datum, no update
T & operator[] ( VIMD & vimd ) { return _mdv[Indx()]; } // Return current datum, update sub array
T & Next () { return _mdv[IndxUpd()]; }
size_t ICurr () const { return _itcurr; } size_t IEnd () const { return _itend; } bool BNext () const { return _itcurr < _itend; } const VIMD & Vitmd () const { return _vimd; } const MDVSLICE & Slice() const { return _mdvSlice; } void SetDimReorder ( const VIMD & vimdDim ) { _vimdDim = vimdDim; _bDimReorder = true; // MSRDEVBUG: assert that the contents mention all dimensions correctly
} TMDVDENSE & Mdv () { return _mdv; } bool BReorder () const { return _bDimReorder; } const VIMD & VimdReorder () const { return _vimdDim; } protected: TMDVDENSE & _mdv; // Flat valarray
const MDVSLICE & _mdvSlice; // Multidimensional slice
VIMD _vimd; // Iteration control
VIMD _vimdDim; // Dimension reordering (optional)
size_t _itcurr; // Current iteration point
size_t _itend; // Iteration terminus
bool _bDimReorder; // Dimension reordering?
};
friend class Iterator;
};
/////////////////////////////////////////////////////////////////////////////////
// MDVSLICE member functions
/////////////////////////////////////////////////////////////////////////////////
inlinevoid MDVSLICE :: StrideFromLength ( const vbool * pvboolMissing ){ size_t cd = _Len.size(); _Stride.resize(cd); size_t c = 1; size_t cmiss = pvboolMissing ? pvboolMissing->size() : 0;
for ( int i = cd; --i >= 0 ; ) { int l = _Len[i]; if ( l == 0 ) continue; if ( i < cmiss && (*pvboolMissing)[i] ) { _Stride[i] = 0; } else { _Stride[i] = c; c *= l; } }}
// Construct a gslice from an MDVSLICE
inlinegslice MDVSLICE :: Gslice () const{ _Sizarray vszLength; _Sizarray vszStride; return gslice( _Start, vdup( vszLength, _Len ), vdup( vszStride, _Stride ) );}
// End of mdvect.h
#endif
|
