TIndexCell Class Reference

sort collection with attributes More...

#include <TIndexCell.h>

Inheritance diagram for TIndexCell:

Collaboration diagram for TIndexCell:

Public Member Functions
Int_t	Add (Int_t narg, Long_t varg[])
Int_t	Add (Long_t p1)
TIndexCell *	At (Int_t idx) const
TIndexCell const *	At (Int_t narg, Int_t vind[]) const
Int_t	Compare (const TObject *obj) const
Int_t	ComparePatterns (Int_t nind, Long_t vdiff[], TIndexCell *cin, Int_t strip=0)
Int_t	ComparePatterns (Int_t nind, TIndexCell *cin, Int_t srtip=0)
void	Delete ()
void	Drop ()
void	Drop (int i)
void	DropButFirst (int level)
void	DropButLast (int level)
int	DropCouples (int level)
TIndexCell *	Find (Int_t narg, Long_t varg[]) const
TIndexCell *	Find (Long_t p1) const
TIndexCell *	FindAdd (Long_t p1)
Int_t	GetEntries () const
Int_t	GetValues (Int_t level, Int_t vind[], Long_t val[]) const
ULong_t	Hash () const
Bool_t	IsEqual (const TObject *obj) const
Bool_t	IsSortable () const
TObjArray *	List () const
Int_t	MaxN (Int_t level) const
Int_t	MaxN (Int_t level, Int_t vind[]) const
Long_t	MaxV (Int_t level) const
Long_t	MaxV (Int_t level, Int_t vind[]) const
Int_t	MinN (Int_t level) const
Int_t	MinN (Int_t level, Int_t vind[]) const
Long_t	MinV (Int_t level) const
Long_t	MinV (Int_t level, Int_t vind[]) const
Int_t	N () const
Int_t	N (Int_t level) const
Int_t	Nlevels () const
void	Print (Option_t *) const
void	PrintPopulation (int level) const
void	PrintStat () const
void	Purge (int level)
void	SetName (const char *varlist)
void	SetValue (Long_t p1)
void	Shift (Int_t n, Long_t vshift[])
void	Shift (Long_t vshift)
void	Sort (Int_t upto=kMaxInt)
	TIndexCell ()
	TIndexCell (const TIndexCell &c)
	TIndexCell (Long_t p1)
Long_t	Value () const
	~TIndexCell ()

Private Attributes
TObjArray *	fList
	list of TIndexCell's More...
Long_t	fValue
	hash value More...

Friends
class	TIndexCellIter
class	TIndexCellIterV

Detailed Description

sort collection with attributes

//////////////////////////////////////////////////////////////////////// // TIndexCell // // sort collection with attributes // // ////////////////////////////////////////////////////////////////////////

Constructor & Destructor Documentation

TIndexCell() [1/3]

TIndexCell::TIndexCell ( )

inline

:fValue(0) { fList=0; }

TIndexCell() [2/3]

TIndexCell::TIndexCell ( Long_t  p1 )

inline

:fValue(p1) { fList=0; }

TIndexCell() [3/3]

TIndexCell::TIndexCell

(

const TIndexCell &

c

)

~TIndexCell()

TIndexCell::~TIndexCell

(

)

{ 
  Delete();
}

Member Function Documentation

Add() [1/2]

Int_t TIndexCell::Add	(	Int_t	narg,
		Long_t	varg[]
	)

{
  if(narg==1) return Add( varg[0] );
  else {
    TIndexCell *b=FindAdd(varg[0]);
    narg--;
    return b->Add( narg, varg+1 );
  }
}

Add() [2/2]

Int_t TIndexCell::Add

(

Long_t

p1

)

{
  if(!fList)     fList = new TObjArray();
  else if( Find(p1) )
      printf("WARNING: TIndexCell::Add(%ld) - object is not unique!\n",p1);
 
  TIndexCell *b= new TIndexCell(p1);
  fList->Add(b);
  return 1;
}

At() [1/2]

TIndexCell * TIndexCell::At ( Int_t  idx ) const

inline

  { if(fList) return (TIndexCell*)(fList->At(idx));
      else return 0; }

At() [2/2]

TIndexCell const * TIndexCell::At	(	Int_t	narg,
		Int_t	vind[]
	)		const

return cell located at vind[narg] address

{
 
  TIndexCell *b=0;
  //  TIndexCell *th=this;
 
  if(nind>0) {
    b = At(vind[0]);
    if(nind==1) return b;
    if(b) {
      nind--;
      return b->At(nind,vind+1);
    }
  }
  else if(nind==0)  return this;
  return 0;
}

Compare()

Int_t TIndexCell::Compare ( const TObject *  obj ) const

inline

    { if (fValue > ((TIndexCell*)obj)->Value())
    return 1;
  else if (fValue < ((TIndexCell*)obj)->Value())
    return -1;
  else
    return 0; }

ComparePatterns() [1/2]

Int_t TIndexCell::ComparePatterns	(	Int_t	nind,
		Long_t	vdiff[],
		TIndexCell *	cin,
		Int_t	strip = 0
	)

Compare 2 TIndexCells of the same structure and find number of common
cells at the given level and if(strip): drop all the rest (for current pattern)
vdiff - is the vector of values (levels) to be taken into account of
the length level
vdiff[i] = 0 - require value of i-th level being the same (exact comparison)
>0 - abs(value2-value1) <= vdiff[i]

{ 
 
  Int_t npat=0;
  if(!cin)      return npat;
  if(!fList)    return npat;
  if(level<1)   return npat;
  Int_t entries = GetEntries();
  if(entries<1) return npat;
 
  Int_t npat0;
  TIndexCell *c1=0;
  TIndexCell *at=0;
 
  npat0=npat=0;
 
  for( int i=entries-1; i>-1; i-- ) {
    at = At(i);
    npat0 = npat;
    if( vdiff[0] == 0 ) {
      c1 = cin->Find(at->Value());
      if( c1 ) {
    if(level==1)     {npat++;}
    else if(level>1) {npat += at->ComparePatterns(level-1,vdiff+1,c1,strip);}
      }
    }
    else if(vdiff[0] > 0 ) {
      for( Long_t j=-vdiff[0]; j<=vdiff[0]; j++ ) {
    c1 = cin->Find( at->Value()+j );
    if( c1 ) {
      if(level==1)     npat++;
      else if(level>1) {
        npat += at->ComparePatterns(level-1,vdiff+1,c1,0);
      }
    }
      }
    }
    //printf("level=%d   i=%d, entries=%d, npat=%d, npat0=%d \n", 
    //  level,i,entries,npat,npat0 );
    if(strip) { 
      if(npat<=npat0) { fList->RemoveAt(i); at->Drop(); delete at; Sort(); }
    }
  }
 
  if(strip) {
    fList->Compress();
    Sort();
  }
 
  return npat;
}

ComparePatterns() [2/2]

Int_t TIndexCell::ComparePatterns	(	Int_t	nind,
		TIndexCell *	cin,
		Int_t	srtip = 0
	)

{ 
  Long_t *vdiff = new Long_t[level];
  for( int i=0; i<level; i++ ) vdiff[i]=0;
  Int_t cp =  ComparePatterns( level, vdiff, cin, strip );
  delete[] vdiff;
  return cp;
}

Delete()

void TIndexCell::Delete

(

)

{ 
  if(fList) {
    int ncc = GetEntries();
    for(int i=0; i<ncc; i++ )  {
      At(i)->Delete();
    }
    fList->Delete();
    delete fList;
    fList=0;
  }
}

Drop() [1/2]

void TIndexCell::Drop

(

)

{ 
  fValue=0;
  Delete();
}

Drop() [2/2]

void TIndexCell::Drop

(

int

i

)

drop i-th cell on the highest level

{ 
 
  if(!fList) return;
  TIndexCell *at = At(i);
  if(at) {
    at->Delete();
    fList->RemoveAt(i);
    delete at; 
    Sort();
  }
}

DropButFirst()

void TIndexCell::DropButFirst

(

int

level

)

drop all elements except of first one in all cells on the level

{ 
 
  if(!fList) return;
  int ncc=GetEntries();
  if(level==0) {
    if(ncc<2) return;
    for(int i=ncc-1; i>0; i--)  Drop(i);
  } else if(level>0) {
    for(int i=0; i<ncc; i++)  At(i)->DropButFirst(level-1);
  }
}

DropButLast()

void TIndexCell::DropButLast

(

int

level

)

drop all elements except of last one in all cells on the level

{ 
 
  if(!fList) return;
  int ncc=GetEntries();
  if(level==0) {
    if(ncc<2) return;
    for( int i=ncc-2; i>=0; i-- )  Drop(i);
  } else if(level>0) {
    for(int i=0; i<ncc; i++)  At(i)->DropButLast(level-1);
  }
}

DropCouples()

int TIndexCell::DropCouples

(

int

level

)

drop all overoccupated cells on the level

{ 
  int count=0;
  if(!fList) return count;
  int ncc=GetEntries();
  if(level==0) {
    for(int i=ncc-1; i>-1; i--)  
      if(ncc>1) { Drop(i); count++;}
  } else if(level>0) {
    for(int i=0; i<ncc; i++)  count+=At(i)->DropCouples(level-1);
  }
  return count;
}

Find() [1/2]

TIndexCell * TIndexCell::Find	(	Int_t	narg,
		Long_t	varg[]
	)		const

{
  if(narg==1) return Find( varg[0] );
  else {
    TIndexCell *b=Find(varg[0]);
    if(b) {
      narg--;
      return b->Find( narg, varg+1 );
    }
  }
  return 0;
}

Find() [2/2]

TIndexCell * TIndexCell::Find

(

Long_t

p1

)

const

{
  if(!fList) return 0;
  TIndexCell a(p1);
  if(!fList->IsSorted())
    return (TIndexCell*)(fList->FindObject(&a));
  Int_t i = fList->BinarySearch(&a);
  if(i>=0) return At(i);
  return 0;
}

FindAdd()

TIndexCell * TIndexCell::FindAdd

(

Long_t

p1

)

{
  TIndexCell *b=0;
 
  if(!fList)   fList = new TObjArray();
  else {
    b = Find(p1);
    if( b )                 return b;
  }
  b= new TIndexCell(p1);
  fList->Add(b);
  return b;
}

GetEntries()

Int_t TIndexCell::GetEntries ( ) const

inline

    { if(fList) return fList->GetEntriesFast();
      else return 0; }

GetValues()

Int_t TIndexCell::GetValues	(	Int_t	level,
		Int_t	vind[],
		Long_t	val[]
	)		const

return vector of values correspondent to indexes on the given level

{
 
  TIndexCell const *b;
  for( int lev=1; lev<=nind; lev++ ) {
    b=At(lev,vind);
    if(!b) return 0;
    val[lev-1]=b->Value();
  }
  return 1;
}

Hash()

ULong_t TIndexCell::Hash ( ) const

inline

{ return fValue; }

IsEqual()

Bool_t TIndexCell::IsEqual ( const TObject *  obj ) const

inline

    { return fValue == ((TIndexCell*)obj)->Value(); }

IsSortable()

Bool_t TIndexCell::IsSortable ( ) const

inline

{ return kTRUE; }

List()

TObjArray * TIndexCell::List ( ) const

inline

{ return fList; }

MaxN() [1/2]

Int_t TIndexCell::MaxN

(

Int_t

level

)

const

return population of the maximal populated cell on the given level

{
  Int_t *vind = new Int_t[level];
  Int_t max = MaxN(level,vind);
  delete[] vind;
  return max;
}

MaxN() [2/2]

Int_t TIndexCell::MaxN	(	Int_t	level,
		Int_t	vind[]
	)		const

return population of the maximal populated cell on the given level and cell address

TODO: check this routine

{
 
 
  if(level==0)
    if(fList) return GetEntries();
  Int_t n=-999999999, k=-999999999;
  if(fList) {
    if(level>0) {
      int nentr=GetEntries();
      for(int i=0; i<nentr; i++)  {
    k=At(i)->MaxN(level-1,vind+1);
    if(n < k) {
      n=k;
      vind[0] = i;
    }
      }
    }
  }
  return n;
}

MaxV() [1/2]

Long_t TIndexCell::MaxV

(

Int_t

level

)

const

return maximal value on the given level

{
  Int_t *vind = new Int_t[level];
  Long_t max = MaxV(level,vind);
  delete[] vind;
  return max;
}

MaxV() [2/2]

Long_t TIndexCell::MaxV	(	Int_t	level,
		Int_t	vind[]
	)		const

return maximal value on the given level and cell address

{
 
  if(level==0)      return fValue;
  Long_t   n=-kMaxInt, k=-kMaxInt;
  if(fList) {
    if(level>0) {
      int ncc = GetEntries();
      for(int i=0; i<ncc; i++) {
    k=At(i)->MaxV(level-1,vind+1);
    if(n < k) {
      n=k;
      vind[0]=i;
    }
      }
    }
  }
  return n;
}

MinN() [1/2]

Int_t TIndexCell::MinN

(

Int_t

level

)

const

return population of the mimimal populated cell on the given level

{
  Int_t *vind = new Int_t[level];
  Int_t min = MinN(level,vind);
  delete[] vind;
  return min;
}

MinN() [2/2]

Int_t TIndexCell::MinN	(	Int_t	level,
		Int_t	vind[]
	)		const

return population of the mimimal populated cell on the given level and cell address

TODO: check this routine

{
 
 
  if(level==0)  
    if(fList) return GetEntries();
  Int_t n=kMaxInt, k=kMaxInt;
  if(fList) {
    if(level>0) {
      int nentr=GetEntries();
      for(int i=0; i<nentr; i++)  {
    k=At(i)->MinN(level-1,vind+1);
    if(n > k) {
      n=k;
      vind[0]=i;
    }
      }
    }
  }
  return n;
}

MinV() [1/2]

Long_t TIndexCell::MinV

(

Int_t

level

)

const

return mimimal value on the given level

{
  Int_t *vind = new Int_t[level];
  Long_t min = MinV(level,vind);
  delete[] vind;
  return min;
}

MinV() [2/2]

Long_t TIndexCell::MinV	(	Int_t	level,
		Int_t	vind[]
	)		const

return mimimal value on the given level and vector of indexes

{
 
  if(level==0)      return fValue;
  Long_t   n=kMaxInt, k=kMaxInt;
  if(fList) {
    if(level>0) {
      int ncc = GetEntries();
      for(int i=0; i<ncc; i++) {
    k=At(i)->MinV(level-1,vind+1);
    if(n > k) {
      n=k;
      vind[0] = i;
    }
      }
    }
  }
  return n;
}

N() [1/2]

Int_t TIndexCell::N

(

)

const

return total number of basic cells (last level where fList=0)

{
  int n=0;
  int ncc = GetEntries();
  if(!fList) n++;
  else for(int i=0; i<ncc; i++)  n += At(i)->N();
  return n;
}

N() [2/2]

Int_t TIndexCell::N

(

Int_t

level

)

const

Nlevels()

Int_t TIndexCell::Nlevels

(

)

const

return maximal depth of nested arrays

{
  int n=0,k=0;
  if(!fList) return 0;
  else {
    int ncc = GetEntries();
    for(int i=0; i<ncc; i++)  {
      k = At(i)->Nlevels();
      if(k>n) n=k;
    }
  }
  return n+1;
}

Print()

void TIndexCell::Print

(

Option_t *

opt

)

const

{ 
  //printf(" %s = ", (this->->List()->GetName());
  printf("%ld\n", fValue);
 
  if(!fList) return;
  int ncc=GetEntries();
  for(int i=0; i<ncc; i++) {
    printf(" %s = ",fList->GetName());
    ((TIndexCell*)fList->At(i))->Print("");
  }
}

PrintPopulation()

void TIndexCell::PrintPopulation

(

int

level

)

const

{
  printf("Population on the level %d\n",level);
  if(GetEntries()>0) {
    TIndexCellIter itr(this,level);
    const TIndexCell *c=0;
    TIndexCell *cn=0;
    TIndexCell hist;
    while( (c=itr.Next()) ) {
      cn = hist.FindAdd((Long_t)(c->N(1)));
      if(!cn->At(0)) cn->Add(0);
      cn->At(0)->SetValue(cn->At(0)->Value()+1); 
    }
    hist.Sort();
    hist.SetName("N:entries");
    hist.Print("");
  }
}

PrintStat()

void TIndexCell::PrintStat

(

)

const

{ 
  printf( "Ncell:   %d\n", N() );
  if(fList) printf( "Nlevels: %d   %s \n", Nlevels(), List()->GetName() );
 
  float phaseVol=1;
  int range=0;
  printf("level\t entries\t range\t occupancy\t minPop\t maxPop\n");
  int nlvl=Nlevels();
  for(int i=1; i<nlvl; i++ ) {
    range = MaxV(i)-MinV(i)+1;
    phaseVol *= range;
#ifdef _WINDOWS
    printf(" %d \t %d \t\t %d \t %f %% \t %d \t %d\n",
#else
    printf(" %d \t %d \t\t %d \t %f \%% \t %d \t %d\n",
#endif
       i,N(i),range,100.*N(i)/phaseVol, MinN(i),MaxN(i) );
  }
#ifdef _WINDOWS
  printf(" %d \t %d \t\t %d \t %f %%\n",
#else
  printf(" %d \t %d \t\t %d \t %f \%%\n",
#endif
     Nlevels(),N(Nlevels()),1,100.*N(Nlevels())/phaseVol );
}

Purge()

void TIndexCell::Purge

(

int

level

)

Drop branches of length < level

{
  if( !fList )   return;
  if( level< 1 ) return;
 
  int entries = GetEntries();
  if( entries<1 ) Drop();
  for(int i=entries-1; i>-1; i--)  {
    //if( At(i)->Nlevels() < level-1 ) { At(i)->Drop();  fList->RemoveAt(i); }
    //??
    if( At(i)->Nlevels()+1 < level-1 ) { At(i)->Drop();  fList->RemoveAt(i); }
    else At(i)->Purge(level-1);
  }
  if(GetEntries()<1)   Drop();
  if(fList) {
    fList->Compress();
    Sort();
  }
}

SetName()

void TIndexCell::SetName

(

const char *

varlist

)

{
  if(!fList) return;
 
  fList->SetName(varlist);
 
  Int_t nch = strlen(varlist);
  if (nch <= 1) return;
 
  const char *newvar=0;
  int i;
  for (i=1;i<nch;i++) {
    if (varlist[i] == ':') {
      if(i+1<nch)  newvar=&varlist[i+1];
      break;
    }
  }
 
  if(!newvar) return;
 
  int ncc = GetEntries();
  for(i=0; i<ncc; i++) 
    ((TIndexCell*)fList->At(i))->SetName(newvar);
}

SetValue()

void TIndexCell::SetValue ( Long_t  p1 )

inline

{ fValue=p1; }

Shift() [1/2]

void TIndexCell::Shift	(	Int_t	n,
		Long_t	vshift[]
	)

Shift al values of level i on the vshift[i]

{ 
 
  int ncc = GetEntries();
  if(level==1)  
    for(int i=0;i<ncc;i++) At(i)->Shift(vshift[0]);
  else if( level>1 ) {
    if(!fList)         return;
    for(int i=0; i<ncc; i++ )  {
      At(i)->Shift(vshift[0]); 
      At(i)->Shift(level-1,vshift+1);
    }
  }
}

Shift() [2/2]

void TIndexCell::Shift ( Long_t  vshift )

inline

{ SetValue( Value()+vshift ); }

Sort()

void TIndexCell::Sort

(

Int_t

upto = kMaxInt

)

{
  if(fList) {
    fList->Sort();
    int ncc = GetEntries();
    for(int i=0; i<ncc; i++) At(i)->Sort();
  }
}

Value()

Long_t TIndexCell::Value ( ) const

inline

{ return fValue; }

Friends And Related Function Documentation

TIndexCellIter

friend class TIndexCellIter

friend

TIndexCellIterV

friend class TIndexCellIterV

friend

Member Data Documentation

fList

TObjArray* TIndexCell::fList

private

list of TIndexCell's

fValue

Long_t TIndexCell::fValue

private

hash value

---

The documentation for this class was generated from the following files:

• /home/antonio/fedra_doxygen/src/libEmath/TIndexCell.h
• /home/antonio/fedra_doxygen/src/libEmath/TIndexCell.cpp