```// @(#)root/physics:\$Id: TRobustEstimator.cxx 30749 2009-10-15 16:33:04Z brun \$
// Author: Anna Kreshuk  08/10/2004

/*************************************************************************
*                                                                       *
* For the licensing terms see \$ROOTSYS/LICENSE.                         *
* For the list of contributors see \$ROOTSYS/README/CREDITS.             *
*************************************************************************/

//////////////////////////////////////////////////////////////////////////////
//
//  TRobustEstimator
//
// Minimum Covariance Determinant Estimator - a Fast Algorithm
// invented by Peter J.Rousseeuw and Katrien Van Dreissen
// "A Fast Algorithm for the Minimum covariance Determinant Estimator"
// Technometrics, August 1999, Vol.41, NO.3
//
// What are robust estimators?
// "An important property of an estimator is its robustness. An estimator
// is called robust if it is insensitive to measurements that deviate
// from the expected behaviour. There are 2 ways to treat such deviating
// measurements: one may either try to recongize them and then remove
// them from the data sample; or one may leave them in the sample, taking
// care that they do not influence the estimate unduly. In both cases robust
// estimators are needed...Robust procedures compensate for systematic errors
// as much as possible, and indicate any situation in which a danger of not being
// able to operate reliably is detected."
// R.Fruhwirth, M.Regler, R.K.Bock, H.Grote, D.Notz
// "Data Analysis Techniques for High-Energy Physics", 2nd edition
//
// What does this algorithm do?
// It computes a highly robust estimator of multivariate location and scatter.
// Then, it takes those estimates to compute robust distances of all the
// data vectors. Those with large robust distances are considered outliers.
// Robust distances can then be plotted for better visualization of the data.
//
// How does this algorithm do it?
// The MCD objective is to find h observations(out of n) whose classical
// covariance matrix has the lowest determinant. The MCD estimator of location
// is then the average of those h points and the MCD estimate of scatter
// is their covariance matrix. The minimum(and default) h = (n+nvariables+1)/2
// so the algorithm is effective when less than (n+nvar+1)/2 variables are outliers.
// The algorithm also allows for exact fit situations - that is, when h or more
// observations lie on a hyperplane. Then the algorithm still yields the MCD location T
// and scatter matrix S, the latter being singular as it should be. From (T,S) the
// program then computes the equation of the hyperplane.
//
// How can this algorithm be used?
// In any case, when contamination of data is suspected, that might influence
// the classical estimates.
// Also, robust estimation of location and scatter is a tool to robustify
// other multivariate techniques such as, for example, principal-component analysis
// and discriminant analysis.
//
//
//
//
// Technical details of the algorithm:
// 0.The default h = (n+nvariables+1)/2, but the user may choose any interger h with
//   (n+nvariables+1)/2<=h<=n. The program then reports the MCD's breakdown value
//   (n-h+1)/n. If you are sure that the dataset contains less than 25% contamination
//   which is usually the case, a good compromise between breakdown value and
//  efficiency is obtained by putting h=[.75*n].
// 1.If h=n,the MCD location estimate is the average of the whole dataset, and
//   the MCD scatter estimate is its covariance matrix. Report this and stop
// 2.If nvariables=1 (univariate data), compute the MCD estimate by the exact
//   algorithm of Rousseeuw and Leroy (1987, pp.171-172) in O(nlogn)time and stop
// 3.From here on, h<n and nvariables>=2.
//   3a.If n is small:
//    - repeat (say) 500 times:
//    -- construct an initial h-subset, starting from a random (nvar+1)-subset
//    -- carry out 2 C-steps (described in the comments of CStep function)
//    - for the 10 results with lowest det(S):
//    -- carry out C-steps until convergence
//    - report the solution (T, S) with the lowest det(S)
//   3b.If n is larger (say, n>600), then
//    - construct up to 5 disjoint random subsets of size nsub (say, nsub=300)
//    - inside each subset repeat 500/5 times:
//    -- construct an initial subset of size hsub=[nsub*h/n]
//    -- carry out 2 C-steps
//    -- keep the best 10 results (Tsub, Ssub)
//    - pool the subsets, yielding the merged set (say, of size nmerged=1500)
//    - in the merged set, repeat for each of the 50 solutions (Tsub, Ssub)
//    -- carry out 2 C-steps
//    -- keep the 10 best results
//    - in the full dataset, repeat for those best results:
//    -- take several C-steps, using n and h
//    -- report the best final result (T, S)
// 4.To obtain consistency when the data comes from a multivariate normal
//   distribution, covariance matrix is multiplied by a correction factor
// 5.Robust distances for all elements, using the final (T, S) are calculated
//   Then the very final mean and covariance estimates are calculated only for
//   values, whose robust distances are less than a cutoff value (0.975 quantile
//   of chi2 distribution with nvariables degrees of freedom)
//
//////////////////////////////////////////////////////////////////////////////

#include "TRobustEstimator.h"
#include "TRandom.h"
#include "TMath.h"
#include "TH1D.h"
#include "TPaveLabel.h"
#include "TDecompChol.h"

ClassImp(TRobustEstimator)

const Double_t kChiMedian[50]= {
0.454937, 1.38629, 2.36597, 3.35670, 4.35146, 5.34812, 6.34581, 7.34412, 8.34283,
9.34182, 10.34, 11.34, 12.34, 13.34, 14.34, 15.34, 16.34, 17.34, 18.34, 19.34,
20.34, 21.34, 22.34, 23.34, 24.34, 25.34, 26.34, 27.34, 28.34, 29.34, 30.34,
31.34, 32.34, 33.34, 34.34, 35.34, 36.34, 37.34, 38.34, 39.34, 40.34,
41.34, 42.34, 43.34, 44.34, 45.34, 46.34, 47.34, 48.34, 49.33};

const Double_t kChiQuant[50]={
5.02389, 7.3776,9.34840,11.1433,12.8325,
14.4494,16.0128,17.5346,19.0228,20.4831,21.920,23.337,
24.736,26.119,27.488,28.845,30.191,31.526,32.852,34.170,
35.479,36.781,38.076,39.364,40.646,41.923,43.194,44.461,
45.722,46.979,48.232,49.481,50.725,51.966,53.203,54.437,
55.668,56.896,58.120,59.342,60.561,61.777,62.990,64.201,
65.410,66.617,67.821,69.022,70.222,71.420};

//_____________________________________________________________________________
TRobustEstimator::TRobustEstimator(){
//this constructor should be used in a univariate case:
//first call this constructor, then - the EvaluateUni(..) function

}

//______________________________________________________________________________
TRobustEstimator::TRobustEstimator(Int_t nvectors, Int_t nvariables, Int_t hh)
:fMean(nvariables),
fCovariance(nvariables),
fInvcovariance(nvariables),
fCorrelation(nvariables),
fRd(nvectors),
fSd(nvectors),
fOut(1),
fHyperplane(nvariables),
fData(nvectors, nvariables)
{
//constructor

if ((nvectors<=1)||(nvariables<=0)){
Error("TRobustEstimator","Not enough vectors or variables");
return;
}
if (nvariables==1){
Error("TRobustEstimator","For the univariate case, use the default constructor and EvaluateUni() function");
return;
}

fN=nvectors;
fNvar=nvariables;
if (hh<(fN+fNvar+1)/2){
if (hh>0)
Warning("TRobustEstimator","chosen h is too small, default h is taken instead");
fH=(fN+fNvar+1)/2;
} else
fH=hh;

fVarTemp=0;
fVecTemp=0;
fExact=0;
}

//_____________________________________________________________________________
{
//adds a column to the data matrix
//it is assumed that the column has size fN
//variable fVarTemp keeps the number of columns l

if (fVarTemp==fNvar) {
fNvar++;
fCovariance.ResizeTo(fNvar, fNvar);
fInvcovariance.ResizeTo(fNvar, fNvar);
fCorrelation.ResizeTo(fNvar, fNvar);
fMean.ResizeTo(fNvar);
fHyperplane.ResizeTo(fNvar);
fData.ResizeTo(fN, fNvar);
}
for (Int_t i=0; i<fN; i++) {
fData(i, fVarTemp)=col[i];
}
fVarTemp++;
}

//_______________________________________________________________________________
{
//adds a vector to the data matrix
//it is supposed that the vector is of size fNvar

if(fVecTemp==fN) {
fN++;
fRd.ResizeTo(fN);
fSd.ResizeTo(fN);
fData.ResizeTo(fN, fNvar);
}
for (Int_t i=0; i<fNvar; i++)
fData(fVecTemp, i)=row[i];

fVecTemp++;
}

//_______________________________________________________________________________
void TRobustEstimator::Evaluate()
{
//Finds the estimate of multivariate mean and variance

Double_t kEps=1e-14;

if (fH==fN){
Warning("Evaluate","Chosen h = #observations, so classic estimates of location and scatter will be calculated");
Classic();
return;
}

Int_t i, j, k;
Int_t ii, jj;
Int_t nmini = 300;
Int_t k1=500;
Int_t nbest=10;
TMatrixD sscp(fNvar+1, fNvar+1);
TVectorD vec(fNvar);

Int_t *index = new Int_t[fN];
Double_t *ndist = new Double_t[fN];
Double_t det;
Double_t *deti=new Double_t[nbest];
for (i=0; i<nbest; i++)
deti[i]=1e16;

for (i=0; i<fN; i++)
fRd(i)=0;
////////////////////////////
//for small n
////////////////////////////
if (fN<nmini*2) {
//for storing the best fMeans and covariances

TMatrixD mstock(nbest, fNvar);
TMatrixD cstock(fNvar, fNvar*nbest);

for (k=0; k<k1; k++) {
CreateSubset(fN, fH, fNvar, index, fData, sscp, ndist);
//calculate the mean and covariance of the created subset
for (i=0; i<fH; i++) {
for(j=0; j<fNvar; j++)
vec(j)=fData[index[i]][j];
}
Covar(sscp, fMean, fCovariance, fSd, fH);
det = fCovariance.Determinant();
if (det < kEps) {
fExact = Exact(ndist);
delete [] index;
delete [] ndist;
delete [] deti;
return;
}
//make 2 CSteps
det = CStep(fN, fH, index, fData, sscp, ndist);
if (det < kEps) {
fExact = Exact(ndist);
delete [] index;
delete [] ndist;
delete [] deti;
return;
}
det = CStep(fN, fH, index, fData, sscp, ndist);
if (det < kEps) {
fExact = Exact(ndist);
delete [] index;
delete [] ndist;
delete [] deti;
return;
} else {
Int_t maxind=TMath::LocMax(nbest, deti);
if(det<deti[maxind]) {
deti[maxind]=det;
for(ii=0; ii<fNvar; ii++) {
mstock(maxind, ii)=fMean(ii);
for(jj=0; jj<fNvar; jj++)
cstock(ii, jj+maxind*fNvar)=fCovariance(ii, jj);
}
}
}
}

//now for nbest best results perform CSteps until convergence

for (i=0; i<nbest; i++) {
for(ii=0; ii<fNvar; ii++) {
fMean(ii)=mstock(i, ii);
for (jj=0; jj<fNvar; jj++)
fCovariance(ii, jj)=cstock(ii, jj+i*fNvar);
}

det=1;
while (det>kEps) {
det=CStep(fN, fH, index, fData, sscp, ndist);
if(TMath::Abs(det-deti[i])<kEps)
break;
else
deti[i]=det;
}
for(ii=0; ii<fNvar; ii++) {
mstock(i,ii)=fMean(ii);
for (jj=0; jj<fNvar; jj++)
cstock(ii,jj+i*fNvar)=fCovariance(ii, jj);
}
}

Int_t detind=TMath::LocMin(nbest, deti);
for(ii=0; ii<fNvar; ii++) {
fMean(ii)=mstock(detind,ii);

for(jj=0; jj<fNvar; jj++)
fCovariance(ii, jj)=cstock(ii,jj+detind*fNvar);
}

if (deti[detind]!=0) {
//calculate robust distances and throw out the bad points
Int_t nout = RDist(sscp);
Double_t cutoff=kChiQuant[fNvar-1];

fOut.Set(nout);

j=0;
for (i=0; i<fN; i++) {
if(fRd(i)>cutoff) {
fOut[j]=i;
j++;
}
}

} else {
fExact=Exact(ndist);
}
delete [] index;
delete [] ndist;
delete [] deti;
return;

}
/////////////////////////////////////////////////
//if n>nmini, the dataset should be partitioned
//partitioning
////////////////////////////////////////////////
Int_t indsubdat[5];
Int_t nsub;
for (ii=0; ii<5; ii++)
indsubdat[ii]=0;

nsub = Partition(nmini, indsubdat);

Int_t sum=0;
for (ii=0; ii<5; ii++)
sum+=indsubdat[ii];
Int_t *subdat=new Int_t[sum];
RDraw(subdat, nsub, indsubdat);
//now the indexes of selected cases are in the array subdat
//matrices to store best means and covariances
Int_t nbestsub=nbest*nsub;
TMatrixD mstockbig(nbestsub, fNvar);
TMatrixD cstockbig(fNvar, fNvar*nbestsub);
TMatrixD hyperplane(nbestsub, fNvar);
for (i=0; i<nbestsub; i++) {
for(j=0; j<fNvar; j++)
hyperplane(i,j)=0;
}
Double_t *detibig = new Double_t[nbestsub];
Int_t maxind;
maxind=TMath::LocMax(5, indsubdat);
TMatrixD dattemp(indsubdat[maxind], fNvar);

Int_t k2=Int_t(k1/nsub);
//construct h-subsets and perform 2 CSteps in subgroups

for (Int_t kgroup=0; kgroup<nsub; kgroup++) {
//printf("group #%d\n", kgroup);
Int_t ntemp=indsubdat[kgroup];
Int_t temp=0;
for (i=0; i<kgroup; i++)
temp+=indsubdat[i];
Int_t par;

for(i=0; i<ntemp; i++) {
for (j=0; j<fNvar; j++) {
dattemp(i,j)=fData[subdat[temp+i]][j];
}
}
Int_t htemp=Int_t(fH*ntemp/fN);

for (i=0; i<nbest; i++)
deti[i]=1e16;

for(k=0; k<k2; k++) {
CreateSubset(ntemp, htemp, fNvar, index, dattemp, sscp, ndist);
for (i=0; i<htemp; i++) {
for(j=0; j<fNvar; j++) {
vec(j)=dattemp(index[i],j);
}
}
Covar(sscp, fMean, fCovariance, fSd, htemp);
det = fCovariance.Determinant();
if (det<kEps) {
par =Exact2(mstockbig, cstockbig, hyperplane, deti, nbest, kgroup, sscp,ndist);
if(par==nbest+1) {

delete [] detibig;
delete [] deti;
delete [] subdat;
delete [] ndist;
delete [] index;
return;
} else
deti[par]=det;
} else {
det = CStep(ntemp, htemp, index, dattemp, sscp, ndist);
if (det<kEps) {
par=Exact2(mstockbig, cstockbig, hyperplane, deti, nbest, kgroup, sscp, ndist);
if(par==nbest+1) {

delete [] detibig;
delete [] deti;
delete [] subdat;
delete [] ndist;
delete [] index;
return;
} else
deti[par]=det;
} else {
det=CStep(ntemp,htemp, index, dattemp, sscp, ndist);
if(det<kEps){
par=Exact2(mstockbig, cstockbig, hyperplane, deti, nbest, kgroup, sscp,ndist);
if(par==nbest+1) {

delete [] detibig;
delete [] deti;
delete [] subdat;
delete [] ndist;
delete [] index;
return;
} else {
deti[par]=det;
}
} else {
maxind=TMath::LocMax(nbest, deti);
if(det<deti[maxind]) {
deti[maxind]=det;
for(i=0; i<fNvar; i++) {
mstockbig(nbest*kgroup+maxind,i)=fMean(i);
for(j=0; j<fNvar; j++) {
cstockbig(i,nbest*kgroup*fNvar+maxind*fNvar+j)=fCovariance(i,j);

}
}
}

}
}
}

maxind=TMath::LocMax(nbest, deti);
if (deti[maxind]<kEps)
break;
}

for(i=0; i<nbest; i++) {
detibig[kgroup*nbest + i]=deti[i];

}

}

//now the arrays mstockbig and cstockbig store nbest*nsub best means and covariances
//detibig stores nbest*nsub their determinants
//merge the subsets and carry out 2 CSteps on the merged set for all 50 best solutions

TMatrixD datmerged(sum, fNvar);
for(i=0; i<sum; i++) {
for (j=0; j<fNvar; j++)
datmerged(i,j)=fData[subdat[i]][j];
}
//  printf("performing calculations for merged set\n");
Int_t hmerged=Int_t(sum*fH/fN);

Int_t nh;
for(k=0; k<nbestsub; k++) {
//for all best solutions perform 2 CSteps and then choose the very best
for(ii=0; ii<fNvar; ii++) {
fMean(ii)=mstockbig(k,ii);
for(jj=0; jj<fNvar; jj++)
fCovariance(ii, jj)=cstockbig(ii,k*fNvar+jj);
}
if(detibig[k]==0) {
for(i=0; i<fNvar; i++)
fHyperplane(i)=hyperplane(k,i);
CreateOrtSubset(datmerged,index, hmerged, sum, sscp, ndist);

}
det=CStep(sum, hmerged, index, datmerged, sscp, ndist);
if (det<kEps) {
nh= Exact(ndist);
if (nh>=fH) {
fExact = nh;

delete [] detibig;
delete [] deti;
delete [] subdat;
delete [] ndist;
delete [] index;
return;
} else {
CreateOrtSubset(datmerged, index, hmerged, sum, sscp, ndist);
}
}

det=CStep(sum, hmerged, index, datmerged, sscp, ndist);
if (det<kEps) {
nh=Exact(ndist);
if (nh>=fH) {
fExact = nh;
delete [] detibig;
delete [] deti;
delete [] subdat;
delete [] ndist;
delete [] index;
return;
}
}
detibig[k]=det;
for(i=0; i<fNvar; i++) {
mstockbig(k,i)=fMean(i);
for(j=0; j<fNvar; j++) {
cstockbig(i,k*fNvar+j)=fCovariance(i, j);
}
}
}
//now for the subset with the smallest determinant
//repeat CSteps until convergence
Int_t minind=TMath::LocMin(nbestsub, detibig);
det=detibig[minind];
for(i=0; i<fNvar; i++) {
fMean(i)=mstockbig(minind,i);
fHyperplane(i)=hyperplane(minind,i);
for(j=0; j<fNvar; j++)
fCovariance(i, j)=cstockbig(i,minind*fNvar + j);
}
if(det<kEps)
CreateOrtSubset(fData, index, fH, fN, sscp, ndist);
det=1;
while (det>kEps) {
det=CStep(fN, fH, index, fData, sscp, ndist);
if(TMath::Abs(det-detibig[minind])<kEps) {
break;
} else {
detibig[minind]=det;
}
}
if(det<kEps) {
Exact(ndist);
fExact=kTRUE;
}
Int_t nout = RDist(sscp);
Double_t cutoff=kChiQuant[fNvar-1];

fOut.Set(nout);

j=0;
for (i=0; i<fN; i++) {
if(fRd(i)>cutoff) {
fOut[j]=i;
j++;
}
}

delete [] detibig;
delete [] deti;
delete [] subdat;
delete [] ndist;
delete [] index;
return;
}

//___________________________________________________________________________________________
void TRobustEstimator::EvaluateUni(Int_t nvectors, Double_t *data, Double_t &mean, Double_t &sigma, Int_t hh)
{
//for the univariate case
//estimates of location and scatter are returned in mean and sigma parameters
//the algorithm works on the same principle as in multivariate case -
//it finds a subset of size hh with smallest sigma, and then returns mean and
//sigma of this subset

if (hh==0)
hh=(nvectors+2)/2;
Double_t faclts[]={2.6477,2.5092,2.3826,2.2662,2.1587,2.0589,1.9660,1.879,1.7973,1.7203,1.6473};
Int_t *index=new Int_t[nvectors];
TMath::Sort(nvectors, data, index, kFALSE);

Int_t nquant;
nquant=TMath::Min(Int_t(Double_t(((hh*1./nvectors)-0.5)*40))+1, 11);
Double_t factor=faclts[nquant-1];

Double_t *aw=new Double_t[nvectors];
Double_t *aw2=new Double_t[nvectors];
Double_t sq=0;
Double_t sqmin=0;
Int_t ndup=0;
Int_t len=nvectors-hh;
Double_t *slutn=new Double_t[len];
for(Int_t i=0; i<len; i++)
slutn[i]=0;
for(Int_t jint=0; jint<len; jint++) {
aw[jint]=0;
for (Int_t j=0; j<hh; j++) {
aw[jint]+=data[index[j+jint]];
if(jint==0)
sq+=data[index[j]]*data[index[j]];
}
aw2[jint]=aw[jint]*aw[jint]/hh;

if(jint==0) {
sq=sq-aw2[jint];
sqmin=sq;
slutn[ndup]=aw[jint];

} else {
sq=sq - data[index[jint-1]]*data[index[jint-1]]+
data[index[jint+hh]]*data[index[jint+hh]]-
aw2[jint]+aw2[jint-1];
if(sq<sqmin) {
ndup=0;
sqmin=sq;
slutn[ndup]=aw[jint];

} else {
if(sq==sqmin) {
ndup++;
slutn[ndup]=aw[jint];
}
}
}
}

slutn[0]=slutn[Int_t((ndup)/2)]/hh;
Double_t bstd=factor*TMath::Sqrt(sqmin/hh);
mean=slutn[0];
sigma=bstd;
delete [] aw;
delete [] aw2;
delete [] slutn;
delete [] index;
}

//_______________________________________________________________________
Int_t TRobustEstimator::GetBDPoint()
{
//returns the breakdown point of the algorithm

Int_t n;
n=(fN-fH+1)/fN;
return n;
}

//_______________________________________________________________________
Double_t TRobustEstimator::GetChiQuant(Int_t i) const
{
//returns the chi2 quantiles

if (i < 0 || i >= 50) return 0;
return kChiQuant[i];
}

//_______________________________________________________________________
void TRobustEstimator::GetCovariance(TMatrixDSym &matr)
{
//returns the covariance matrix

if (matr.GetNrows()!=fNvar || matr.GetNcols()!=fNvar){
Warning("GetCovariance","provided matrix is of the wrong size, it will be resized");
matr.ResizeTo(fNvar, fNvar);
}
matr=fCovariance;
}

//_______________________________________________________________________
void TRobustEstimator::GetCorrelation(TMatrixDSym &matr)
{
//returns the correlation matrix

if (matr.GetNrows()!=fNvar || matr.GetNcols()!=fNvar) {
Warning("GetCorrelation","provided matrix is of the wrong size, it will be resized");
matr.ResizeTo(fNvar, fNvar);
}
matr=fCorrelation;
}

//____________________________________________________________________
const TVectorD* TRobustEstimator::GetHyperplane() const
{
//if the points are on a hyperplane, returns this hyperplane

if (fExact==0) {
Error("GetHyperplane","the data doesn't lie on a hyperplane!\n");
return 0;
} else {
return &fHyperplane;
}
}

//______________________________________________________________________
void TRobustEstimator::GetHyperplane(TVectorD &vec)
{
//if the points are on a hyperplane, returns this hyperplane

if (fExact==0){
Error("GetHyperplane","the data doesn't lie on a hyperplane!\n");
return;
}
if (vec.GetNoElements()!=fNvar) {
Warning("GetHyperPlane","provided vector is of the wrong size, it will be resized");
vec.ResizeTo(fNvar);
}
vec=fHyperplane;
}

//________________________________________________________________________
void TRobustEstimator::GetMean(TVectorD &means)
{
//return the estimate of the mean

if (means.GetNoElements()!=fNvar) {
Warning("GetMean","provided vector is of the wrong size, it will be resized");
means.ResizeTo(fNvar);
}
means=fMean;
}

//_________________________________________________________________________
void TRobustEstimator::GetRDistances(TVectorD &rdist)
{
//returns the robust distances (helps to find outliers)

if (rdist.GetNoElements()!=fN) {
Warning("GetRDistances","provided vector is of the wrong size, it will be resized");
rdist.ResizeTo(fN);
}
rdist=fRd;
}

//__________________________________________________________________________
Int_t TRobustEstimator::GetNOut()
{
//returns the number of outliers

return fOut.GetSize();
}

//_________________________________________________________________________
{
//update the sscp matrix with vector vec

Int_t i, j;
for (j=1; j<fNvar+1; j++) {
sscp(0, j) +=vec(j-1);
sscp(j, 0) = sscp(0, j);
}
for (i=1; i<fNvar+1; i++) {
for (j=1; j<fNvar+1; j++) {
sscp(i, j) += vec(i-1)*vec(j-1);
}
}
}

//__________________________________________________________________________
{
//clear the sscp matrix, used for covariance and mean calculation

for (Int_t i=0; i<fNvar+1; i++) {
for (Int_t j=0; j<fNvar+1; j++) {
sscp(i, j)=0;
}
}
}

//_______________________________________________________________
void TRobustEstimator::Classic()
{
//called when h=n. Returns classic covariance matrix
//and mean
TMatrixD sscp(fNvar+1, fNvar+1);
TVectorD temp(fNvar);
for (Int_t i=0; i<fN; i++) {
for (Int_t j=0; j<fNvar; j++)
temp(j)=fData(i, j);
}
Covar(sscp, fMean, fCovariance, fSd, fN);
Correl();

}

//____________________________________________________________________
void TRobustEstimator::Covar(TMatrixD &sscp, TVectorD &m, TMatrixDSym &cov, TVectorD &sd, Int_t nvec)
{
//calculates mean and covariance

Int_t i, j;
Double_t f;
for (i=0; i<fNvar; i++) {
m(i)=sscp(0, i+1);
sd[i]=sscp(i+1, i+1);
f=(sd[i]-m(i)*m(i)/nvec)/(nvec-1);
if (f>1e-14) sd[i]=TMath::Sqrt(f);
else sd[i]=0;
m(i)/=nvec;
}
for (i=0; i<fNvar; i++) {
for (j=0; j<fNvar; j++) {
cov(i, j)=sscp(i+1, j+1)-nvec*m(i)*m(j);
cov(i, j)/=nvec-1;
}
}
}

//____________________________________________________________________
void TRobustEstimator::Correl()
{
//transforms covariance matrix into correlation matrix

Int_t i, j;
Double_t *sd=new Double_t[fNvar];
for(j=0; j<fNvar; j++)
sd[j]=1./TMath::Sqrt(fCovariance(j, j));
for(i=0; i<fNvar; i++) {
for (j=0; j<fNvar; j++) {
if (i==j)
fCorrelation(i, j)=1.;
else
fCorrelation(i, j)=fCovariance(i, j)*sd[i]*sd[j];
}
}
delete [] sd;
}

//____________________________________________________________________
void TRobustEstimator::CreateSubset(Int_t ntotal, Int_t htotal, Int_t p, Int_t *index, TMatrixD &data, TMatrixD &sscp, Double_t *ndist)
{
//creates a subset of htotal elements from ntotal elements
//first, p+1 elements are drawn randomly(without repetitions)
//if their covariance matrix is singular, more elements are
//added one by one, until their covariance matrix becomes regular
//or it becomes clear that htotal observations lie on a hyperplane
//If covariance matrix determinant!=0, distances of all ntotal elements
//are calculated, using formula d_i=Sqrt((x_i-M)*S_inv*(x_i-M)), where
//M is mean and S_inv is the inverse of the covariance matrix
//htotal points with smallest distances are included in the returned subset.

Double_t kEps = 1e-14;
Int_t i, j;
Bool_t repeat=kFALSE;
Int_t nindex=0;
Int_t num;
for(i=0; i<ntotal; i++)
index[i]=ntotal+1;

for (i=0; i<p+1; i++) {
num=Int_t(gRandom->Uniform(0, 1)*(ntotal-1));
if (i>0){
for(j=0; j<=i-1; j++) {
if(index[j]==num)
repeat=kTRUE;
}
}
if(repeat==kTRUE) {
i--;
repeat=kFALSE;
} else {
index[i]=num;
nindex++;
}
}

TVectorD vec(fNvar);
Double_t det;
for (i=0; i<p+1; i++) {
for (j=0; j<fNvar; j++) {
vec[j]=data[index[i]][j];

}
}

Covar(sscp, fMean, fCovariance, fSd, p+1);
det=fCovariance.Determinant();
while((det<kEps)&&(nindex < htotal)) {
//if covariance matrix is singular,another vector is added until
//the matrix becomes regular or it becomes clear that all
//vectors of the group lie on a hyperplane
repeat=kFALSE;
do{
num=Int_t(gRandom->Uniform(0,1)*(ntotal-1));
repeat=kFALSE;
for(i=0; i<nindex; i++) {
if(index[i]==num) {
repeat=kTRUE;
break;
}
}
}while(repeat==kTRUE);

index[nindex]=num;
nindex++;
//check if covariance matrix is singular
for(j=0; j<fNvar; j++)
vec[j]=data[index[nindex-1]][j];
Covar(sscp, fMean, fCovariance, fSd, nindex);
det=fCovariance.Determinant();
}

if(nindex!=htotal) {
TDecompChol chol(fCovariance);
fInvcovariance = chol.Invert();

TVectorD temp(fNvar);
for(j=0; j<ntotal; j++) {
ndist[j]=0;
for(i=0; i<fNvar; i++)
temp[i]=data[j][i] - fMean(i);
temp*=fInvcovariance;
for(i=0; i<fNvar; i++)
ndist[j]+=(data[j][i]-fMean(i))*temp[i];
}
KOrdStat(ntotal, ndist, htotal-1,index);
}

}

//_____________________________________________________________________________
void TRobustEstimator::CreateOrtSubset(TMatrixD &dat,Int_t *index, Int_t hmerged, Int_t nmerged, TMatrixD &sscp, Double_t *ndist)
{
//creates a subset of hmerged vectors with smallest orthogonal distances to the hyperplane
//hyp[1]*(x1-mean[1])+...+hyp[nvar]*(xnvar-mean[nvar])=0
//This function is called in case when less than fH samples lie on a hyperplane.

Int_t i, j;
TVectorD vec(fNvar);
for (i=0; i<nmerged; i++) {
ndist[i]=0;
for(j=0; j<fNvar; j++) {
ndist[i]+=fHyperplane[j]*(dat[i][j]-fMean[j]);
ndist[i]=TMath::Abs(ndist[i]);
}
}
KOrdStat(nmerged, ndist, hmerged-1, index);
for (i=0; i<hmerged; i++) {
for(j=0; j<fNvar; j++)
vec[j]=dat[index[i]][j];
}
Covar(sscp, fMean, fCovariance, fSd, hmerged);
}

//__________________________________________________________________________
Double_t TRobustEstimator::CStep(Int_t ntotal, Int_t htotal, Int_t *index, TMatrixD &data, TMatrixD &sscp, Double_t *ndist)
{
//from the input htotal-subset constructs another htotal subset with lower determinant
//
//As proven by Peter J.Rousseeuw and Katrien Van Driessen, if distances for all elements
//are calculated, using the formula:d_i=Sqrt((x_i-M)*S_inv*(x_i-M)), where M is the mean
//of the input htotal-subset, and S_inv - the inverse of its covariance matrix, then
//htotal elements with smallest distances will have covariance matrix with determinant
//less or equal to the determinant of the input subset covariance matrix.
//
//determinant for this htotal-subset with smallest distances is returned

Int_t i, j;
TVectorD vec(fNvar);
Double_t det;

TDecompChol chol(fCovariance);
fInvcovariance = chol.Invert();

TVectorD temp(fNvar);
for(j=0; j<ntotal; j++) {
ndist[j]=0;
for(i=0; i<fNvar; i++)
temp[i]=data[j][i]-fMean[i];
temp*=fInvcovariance;
for(i=0; i<fNvar; i++)
ndist[j]+=(data[j][i]-fMean[i])*temp[i];
}

//taking h smallest
KOrdStat(ntotal, ndist, htotal-1, index);
//writing their mean and covariance
for (i=0; i<htotal; i++) {
for (j=0; j<fNvar; j++)
temp[j]=data[index[i]][j];
}
Covar(sscp, fMean, fCovariance, fSd, htotal);
det = fCovariance.Determinant();
return det;
}

//_______________________________________________________________
Int_t TRobustEstimator::Exact(Double_t *ndist)
{
//for the exact fit situaions
//returns number of observations on the hyperplane

Int_t i, j;

TMatrixDSymEigen eigen(fCovariance);
TVectorD eigenValues=eigen.GetEigenValues();
TMatrixD eigenMatrix=eigen.GetEigenVectors();

for (j=0; j<fNvar; j++) {
fHyperplane[j]=eigenMatrix(j,fNvar-1);
}
//calculate and return how many observations lie on the hyperplane
for (i=0; i<fN; i++) {
ndist[i]=0;
for(j=0; j<fNvar; j++) {
ndist[i]+=fHyperplane[j]*(fData[i][j]-fMean[j]);
ndist[i]=TMath::Abs(ndist[i]);
}
}
Int_t nhyp=0;

for (i=0; i<fN; i++) {
if(ndist[i] < 1e-14) nhyp++;
}
return nhyp;

}

//____________________________________________________________________________
Int_t TRobustEstimator::Exact2(TMatrixD &mstockbig, TMatrixD &cstockbig, TMatrixD &hyperplane,
Double_t *deti, Int_t nbest, Int_t kgroup,
TMatrixD &sscp, Double_t *ndist)
{
//This function is called if determinant of the covariance matrix of a subset=0.
//
//If there are more then fH vectors on a hyperplane,
//returns this hyperplane and stops
//else stores the hyperplane coordinates in hyperplane matrix

Int_t i, j;

TVectorD vec(fNvar);
Int_t maxind = TMath::LocMax(nbest, deti);
Int_t nh=Exact(ndist);
//now nh is the number of observation on the hyperplane
//ndist stores distances of observation from this hyperplane
if(nh>=fH) {
for (i=0; i<fN; i++) {
if(ndist[i]<1e-14) {
for (j=0; j<fNvar; j++)
vec[j]=fData[i][j];
}
}
Covar(sscp, fMean, fCovariance, fSd, nh);

fExact=nh;
return nbest+1;

} else {
//if less than fH observations lie on a hyperplane,
//mean and covariance matrix are stored in mstockbig
//and cstockbig in place of the previous maximum determinant
//mean and covariance
for(i=0; i<fNvar; i++) {
mstockbig(nbest*kgroup+maxind,i)=fMean(i);
hyperplane(nbest*kgroup+maxind,i)=fHyperplane(i);
for(j=0; j<fNvar; j++) {
cstockbig(i,nbest*kgroup*fNvar+maxind*fNvar+j)=fCovariance(i,j);
}
}
return maxind;
}
}

//_____________________________________________________________________________
Int_t TRobustEstimator::Partition(Int_t nmini, Int_t *indsubdat)
{
//divides the elements into approximately equal subgroups
//number of elements in each subgroup is stored in indsubdat
//number of subgroups is returned

Int_t nsub;
if ((fN>=2*nmini) && (fN<=(3*nmini-1))) {
if (fN%2==1){
indsubdat[0]=Int_t(fN*0.5);
indsubdat[1]=Int_t(fN*0.5)+1;
} else
indsubdat[0]=indsubdat[1]=Int_t(fN/2);
nsub=2;
}
else{
if((fN>=3*nmini) && (fN<(4*nmini -1))) {
if(fN%3==0){
indsubdat[0]=indsubdat[1]=indsubdat[2]=Int_t(fN/3);
} else {
indsubdat[0]=Int_t(fN/3);
indsubdat[1]=Int_t(fN/3)+1;
if (fN%3==1) indsubdat[2]=Int_t(fN/3);
else indsubdat[2]=Int_t(fN/3)+1;
}
nsub=3;
}
else{
if((fN>=4*nmini)&&(fN<=(5*nmini-1))){
if (fN%4==0) indsubdat[0]=indsubdat[1]=indsubdat[2]=indsubdat[3]=Int_t(fN/4);
else {
indsubdat[0]=Int_t(fN/4);
indsubdat[1]=Int_t(fN/4)+1;
if(fN%4==1) indsubdat[2]=indsubdat[3]=Int_t(fN/4);
if(fN%4==2) {
indsubdat[2]=Int_t(fN/4)+1;
indsubdat[3]=Int_t(fN/4);
}
if(fN%4==3) indsubdat[2]=indsubdat[3]=Int_t(fN/4)+1;
}
nsub=4;
} else {
for(Int_t i=0; i<5; i++)
indsubdat[i]=nmini;
nsub=5;
}
}
}
return nsub;
}

//___________________________________________________________________________
Int_t TRobustEstimator::RDist(TMatrixD &sscp)
{
//Calculates robust distances.Then the samples with robust distances
//greater than a cutoff value (0.975 quantile of chi2 distribution with
//fNvar degrees of freedom, multiplied by a correction factor), are given
//weiht=0, and new, reweighted estimates of location and scatter are calculated
//The function returns the number of outliers.

Int_t i, j;
Int_t nout=0;

TVectorD temp(fNvar);
TDecompChol chol(fCovariance);
fInvcovariance = chol.Invert();

for (i=0; i<fN; i++) {
fRd[i]=0;
for(j=0; j<fNvar; j++) {
temp[j]=fData[i][j]-fMean[j];
}
temp*=fInvcovariance;
for(j=0; j<fNvar; j++) {
fRd[i]+=(fData[i][j]-fMean[j])*temp[j];
}
}

Double_t med;
Double_t chi = kChiMedian[fNvar-1];

med=TMath::Median(fN, fRd.GetMatrixArray());
med/=chi;
fCovariance*=med;
TDecompChol chol2(fCovariance);
fInvcovariance = chol2.Invert();

for (i=0; i<fN; i++) {
fRd[i]=0;
for(j=0; j<fNvar; j++) {
temp[j]=fData[i][j]-fMean[j];
}

temp*=fInvcovariance;
for(j=0; j<fNvar; j++) {
fRd[i]+=(fData[i][j]-fMean[j])*temp[j];
}
}

Double_t cutoff = kChiQuant[fNvar-1];

for(i=0; i<fN; i++) {
if (fRd[i]<=cutoff) {
for(j=0; j<fNvar; j++)
temp[j]=fData[i][j];
} else {
nout++;
}
}

Covar(sscp, fMean, fCovariance, fSd, fN-nout);
return nout;
}

//____________________________________________________________________________
void TRobustEstimator::RDraw(Int_t *subdat, Int_t ngroup, Int_t *indsubdat)
{
//Draws ngroup nonoverlapping subdatasets out of a dataset of size n
//such that the selected case numbers are uniformly distributed from 1 to n

Int_t jndex = 0;
Int_t nrand;
Int_t i, k, m, j;
for (k=1; k<=ngroup; k++) {
for (m=1; m<=indsubdat[k-1]; m++) {

nrand = Int_t(gRandom->Uniform(0, 1) * (fN-jndex))+1;

jndex++;
if (jndex==1) {
subdat[0]=nrand;
} else {
subdat[jndex-1]=nrand+jndex-2;
for (i=1; i<=jndex-1; i++) {
if(subdat[i-1] > nrand+i-2) {
for(j=jndex; j>=i+1; j--) {
subdat[j-1]=subdat[j-2];
}
subdat[i-1]=nrand+i-2;
break;  //breaking the loop for(i=1...
}
}
}
}
}
}

//_____________________________________________________________________________
Double_t TRobustEstimator::KOrdStat(Int_t ntotal, Double_t *a, Int_t k, Int_t *work){
//because I need an Int_t work array
Bool_t isAllocated = kFALSE;
const Int_t kWorkMax=100;
Int_t i, ir, j, l, mid;
Int_t arr;
Int_t *ind;
Int_t workLocal[kWorkMax];
Int_t temp;

if (work) {
ind = work;
} else {
ind = workLocal;
if (ntotal > kWorkMax) {
isAllocated = kTRUE;
ind = new Int_t[ntotal];
}
}

for (Int_t ii=0; ii<ntotal; ii++) {
ind[ii]=ii;
}
Int_t rk = k;
l=0;
ir = ntotal-1;
for(;;) {
if (ir<=l+1) { //active partition contains 1 or 2 elements
if (ir == l+1 && a[ind[ir]]<a[ind[l]])
{temp = ind[l]; ind[l]=ind[ir]; ind[ir]=temp;}
Double_t tmp = a[ind[rk]];
if (isAllocated)
delete [] ind;
return tmp;
} else {
mid = (l+ir) >> 1; //choose median of left, center and right
{temp = ind[mid]; ind[mid]=ind[l+1]; ind[l+1]=temp;}//elements as partitioning element arr.
if (a[ind[l]]>a[ind[ir]])  //also rearrange so that a[l]<=a[l+1]
{temp = ind[l]; ind[l]=ind[ir]; ind[ir]=temp;}

if (a[ind[l+1]]>a[ind[ir]])
{temp=ind[l+1]; ind[l+1]=ind[ir]; ind[ir]=temp;}

if (a[ind[l]]>a[ind[l+1]])
{temp = ind[l]; ind[l]=ind[l+1]; ind[l+1]=temp;}

i=l+1;        //initialize pointers for partitioning
j=ir;
arr = ind[l+1];
for (;;) {
do i++; while (a[ind[i]]<a[arr]);
do j--; while (a[ind[j]]>a[arr]);
if (j<i) break;  //pointers crossed, partitioning complete
{temp=ind[i]; ind[i]=ind[j]; ind[j]=temp;}
}
ind[l+1]=ind[j];
ind[j]=arr;
if (j>=rk) ir = j-1; //keep active the partition that
if (j<=rk) l=i;      //contains the k_th element
}
}
}
```
TRobustEstimator.cxx:1
TRobustEstimator.cxx:2
TRobustEstimator.cxx:3
TRobustEstimator.cxx:4
TRobustEstimator.cxx:5
TRobustEstimator.cxx:6
TRobustEstimator.cxx:7
TRobustEstimator.cxx:8
TRobustEstimator.cxx:9
TRobustEstimator.cxx:10
TRobustEstimator.cxx:11
TRobustEstimator.cxx:12
TRobustEstimator.cxx:13
TRobustEstimator.cxx:14
TRobustEstimator.cxx:15
TRobustEstimator.cxx:16
TRobustEstimator.cxx:17
TRobustEstimator.cxx:18
TRobustEstimator.cxx:19
TRobustEstimator.cxx:20
TRobustEstimator.cxx:21
TRobustEstimator.cxx:22
TRobustEstimator.cxx:23
TRobustEstimator.cxx:24
TRobustEstimator.cxx:25
TRobustEstimator.cxx:26
TRobustEstimator.cxx:27
TRobustEstimator.cxx:28
TRobustEstimator.cxx:29
TRobustEstimator.cxx:30
TRobustEstimator.cxx:31
TRobustEstimator.cxx:32
TRobustEstimator.cxx:33
TRobustEstimator.cxx:34
TRobustEstimator.cxx:35
TRobustEstimator.cxx:36
TRobustEstimator.cxx:37
TRobustEstimator.cxx:38
TRobustEstimator.cxx:39
TRobustEstimator.cxx:40
TRobustEstimator.cxx:41
TRobustEstimator.cxx:42
TRobustEstimator.cxx:43
TRobustEstimator.cxx:44
TRobustEstimator.cxx:45
TRobustEstimator.cxx:46
TRobustEstimator.cxx:47
TRobustEstimator.cxx:48
TRobustEstimator.cxx:49
TRobustEstimator.cxx:50
TRobustEstimator.cxx:51
TRobustEstimator.cxx:52
TRobustEstimator.cxx:53
TRobustEstimator.cxx:54
TRobustEstimator.cxx:55
TRobustEstimator.cxx:56
TRobustEstimator.cxx:57
TRobustEstimator.cxx:58
TRobustEstimator.cxx:59
TRobustEstimator.cxx:60
TRobustEstimator.cxx:61
TRobustEstimator.cxx:62
TRobustEstimator.cxx:63
TRobustEstimator.cxx:64
TRobustEstimator.cxx:65
TRobustEstimator.cxx:66
TRobustEstimator.cxx:67
TRobustEstimator.cxx:68
TRobustEstimator.cxx:69
TRobustEstimator.cxx:70
TRobustEstimator.cxx:71
TRobustEstimator.cxx:72
TRobustEstimator.cxx:73
TRobustEstimator.cxx:74
TRobustEstimator.cxx:75
TRobustEstimator.cxx:76
TRobustEstimator.cxx:77
TRobustEstimator.cxx:78
TRobustEstimator.cxx:79
TRobustEstimator.cxx:80
TRobustEstimator.cxx:81
TRobustEstimator.cxx:82
TRobustEstimator.cxx:83
TRobustEstimator.cxx:84
TRobustEstimator.cxx:85
TRobustEstimator.cxx:86
TRobustEstimator.cxx:87
TRobustEstimator.cxx:88
TRobustEstimator.cxx:89
TRobustEstimator.cxx:90
TRobustEstimator.cxx:91
TRobustEstimator.cxx:92
TRobustEstimator.cxx:93
TRobustEstimator.cxx:94
TRobustEstimator.cxx:95
TRobustEstimator.cxx:96
TRobustEstimator.cxx:97
TRobustEstimator.cxx:98
TRobustEstimator.cxx:99
TRobustEstimator.cxx:100
TRobustEstimator.cxx:101
TRobustEstimator.cxx:102
TRobustEstimator.cxx:103
TRobustEstimator.cxx:104
TRobustEstimator.cxx:105
TRobustEstimator.cxx:106
TRobustEstimator.cxx:107
TRobustEstimator.cxx:108
TRobustEstimator.cxx:109
TRobustEstimator.cxx:110
TRobustEstimator.cxx:111
TRobustEstimator.cxx:112
TRobustEstimator.cxx:113
TRobustEstimator.cxx:114
TRobustEstimator.cxx:115
TRobustEstimator.cxx:116
TRobustEstimator.cxx:117
TRobustEstimator.cxx:118
TRobustEstimator.cxx:119
TRobustEstimator.cxx:120
TRobustEstimator.cxx:121
TRobustEstimator.cxx:122
TRobustEstimator.cxx:123
TRobustEstimator.cxx:124
TRobustEstimator.cxx:125
TRobustEstimator.cxx:126
TRobustEstimator.cxx:127
TRobustEstimator.cxx:128
TRobustEstimator.cxx:129
TRobustEstimator.cxx:130
TRobustEstimator.cxx:131
TRobustEstimator.cxx:132
TRobustEstimator.cxx:133
TRobustEstimator.cxx:134
TRobustEstimator.cxx:135
TRobustEstimator.cxx:136
TRobustEstimator.cxx:137
TRobustEstimator.cxx:138
TRobustEstimator.cxx:139
TRobustEstimator.cxx:140
TRobustEstimator.cxx:141
TRobustEstimator.cxx:142
TRobustEstimator.cxx:143
TRobustEstimator.cxx:144
TRobustEstimator.cxx:145
TRobustEstimator.cxx:146
TRobustEstimator.cxx:147
TRobustEstimator.cxx:148
TRobustEstimator.cxx:149
TRobustEstimator.cxx:150
TRobustEstimator.cxx:151
TRobustEstimator.cxx:152
TRobustEstimator.cxx:153
TRobustEstimator.cxx:154
TRobustEstimator.cxx:155
TRobustEstimator.cxx:156
TRobustEstimator.cxx:157
TRobustEstimator.cxx:158
TRobustEstimator.cxx:159
TRobustEstimator.cxx:160
TRobustEstimator.cxx:161
TRobustEstimator.cxx:162
TRobustEstimator.cxx:163
TRobustEstimator.cxx:164
TRobustEstimator.cxx:165
TRobustEstimator.cxx:166
TRobustEstimator.cxx:167
TRobustEstimator.cxx:168
TRobustEstimator.cxx:169
TRobustEstimator.cxx:170
TRobustEstimator.cxx:171
TRobustEstimator.cxx:172
TRobustEstimator.cxx:173
TRobustEstimator.cxx:174
TRobustEstimator.cxx:175
TRobustEstimator.cxx:176
TRobustEstimator.cxx:177
TRobustEstimator.cxx:178
TRobustEstimator.cxx:179
TRobustEstimator.cxx:180
TRobustEstimator.cxx:181
TRobustEstimator.cxx:182
TRobustEstimator.cxx:183
TRobustEstimator.cxx:184
TRobustEstimator.cxx:185
TRobustEstimator.cxx:186
TRobustEstimator.cxx:187
TRobustEstimator.cxx:188
TRobustEstimator.cxx:189
TRobustEstimator.cxx:190
TRobustEstimator.cxx:191
TRobustEstimator.cxx:192
TRobustEstimator.cxx:193
TRobustEstimator.cxx:194
TRobustEstimator.cxx:195
TRobustEstimator.cxx:196
TRobustEstimator.cxx:197
TRobustEstimator.cxx:198
TRobustEstimator.cxx:199
TRobustEstimator.cxx:200
TRobustEstimator.cxx:201
TRobustEstimator.cxx:202
TRobustEstimator.cxx:203
TRobustEstimator.cxx:204
TRobustEstimator.cxx:205
TRobustEstimator.cxx:206
TRobustEstimator.cxx:207
TRobustEstimator.cxx:208
TRobustEstimator.cxx:209
TRobustEstimator.cxx:210
TRobustEstimator.cxx:211
TRobustEstimator.cxx:212
TRobustEstimator.cxx:213
TRobustEstimator.cxx:214
TRobustEstimator.cxx:215
TRobustEstimator.cxx:216
TRobustEstimator.cxx:217
TRobustEstimator.cxx:218
TRobustEstimator.cxx:219
TRobustEstimator.cxx:220
TRobustEstimator.cxx:221
TRobustEstimator.cxx:222
TRobustEstimator.cxx:223
TRobustEstimator.cxx:224
TRobustEstimator.cxx:225
TRobustEstimator.cxx:226
TRobustEstimator.cxx:227
TRobustEstimator.cxx:228
TRobustEstimator.cxx:229
TRobustEstimator.cxx:230
TRobustEstimator.cxx:231
TRobustEstimator.cxx:232
TRobustEstimator.cxx:233
TRobustEstimator.cxx:234
TRobustEstimator.cxx:235
TRobustEstimator.cxx:236
TRobustEstimator.cxx:237
TRobustEstimator.cxx:238
TRobustEstimator.cxx:239
TRobustEstimator.cxx:240
TRobustEstimator.cxx:241
TRobustEstimator.cxx:242
TRobustEstimator.cxx:243
TRobustEstimator.cxx:244
TRobustEstimator.cxx:245
TRobustEstimator.cxx:246
TRobustEstimator.cxx:247
TRobustEstimator.cxx:248
TRobustEstimator.cxx:249
TRobustEstimator.cxx:250
TRobustEstimator.cxx:251
TRobustEstimator.cxx:252
TRobustEstimator.cxx:253
TRobustEstimator.cxx:254
TRobustEstimator.cxx:255
TRobustEstimator.cxx:256
TRobustEstimator.cxx:257
TRobustEstimator.cxx:258
TRobustEstimator.cxx:259
TRobustEstimator.cxx:260
TRobustEstimator.cxx:261
TRobustEstimator.cxx:262
TRobustEstimator.cxx:263
TRobustEstimator.cxx:264
TRobustEstimator.cxx:265
TRobustEstimator.cxx:266
TRobustEstimator.cxx:267
TRobustEstimator.cxx:268
TRobustEstimator.cxx:269
TRobustEstimator.cxx:270
TRobustEstimator.cxx:271
TRobustEstimator.cxx:272
TRobustEstimator.cxx:273
TRobustEstimator.cxx:274
TRobustEstimator.cxx:275
TRobustEstimator.cxx:276
TRobustEstimator.cxx:277
TRobustEstimator.cxx:278
TRobustEstimator.cxx:279
TRobustEstimator.cxx:280
TRobustEstimator.cxx:281
TRobustEstimator.cxx:282
TRobustEstimator.cxx:283
TRobustEstimator.cxx:284
TRobustEstimator.cxx:285
TRobustEstimator.cxx:286
TRobustEstimator.cxx:287
TRobustEstimator.cxx:288
TRobustEstimator.cxx:289
TRobustEstimator.cxx:290
TRobustEstimator.cxx:291
TRobustEstimator.cxx:292
TRobustEstimator.cxx:293
TRobustEstimator.cxx:294
TRobustEstimator.cxx:295
TRobustEstimator.cxx:296
TRobustEstimator.cxx:297
TRobustEstimator.cxx:298
TRobustEstimator.cxx:299
TRobustEstimator.cxx:300
TRobustEstimator.cxx:301
TRobustEstimator.cxx:302
TRobustEstimator.cxx:303
TRobustEstimator.cxx:304
TRobustEstimator.cxx:305
TRobustEstimator.cxx:306
TRobustEstimator.cxx:307
TRobustEstimator.cxx:308
TRobustEstimator.cxx:309
TRobustEstimator.cxx:310
TRobustEstimator.cxx:311
TRobustEstimator.cxx:312
TRobustEstimator.cxx:313
TRobustEstimator.cxx:314
TRobustEstimator.cxx:315
TRobustEstimator.cxx:316
TRobustEstimator.cxx:317
TRobustEstimator.cxx:318
TRobustEstimator.cxx:319
TRobustEstimator.cxx:320
TRobustEstimator.cxx:321
TRobustEstimator.cxx:322
TRobustEstimator.cxx:323
TRobustEstimator.cxx:324
TRobustEstimator.cxx:325
TRobustEstimator.cxx:326
TRobustEstimator.cxx:327
TRobustEstimator.cxx:328
TRobustEstimator.cxx:329
TRobustEstimator.cxx:330
TRobustEstimator.cxx:331
TRobustEstimator.cxx:332
TRobustEstimator.cxx:333
TRobustEstimator.cxx:334
TRobustEstimator.cxx:335
TRobustEstimator.cxx:336
TRobustEstimator.cxx:337
TRobustEstimator.cxx:338
TRobustEstimator.cxx:339
TRobustEstimator.cxx:340
TRobustEstimator.cxx:341
TRobustEstimator.cxx:342
TRobustEstimator.cxx:343
TRobustEstimator.cxx:344
TRobustEstimator.cxx:345
TRobustEstimator.cxx:346
TRobustEstimator.cxx:347
TRobustEstimator.cxx:348
TRobustEstimator.cxx:349
TRobustEstimator.cxx:350
TRobustEstimator.cxx:351
TRobustEstimator.cxx:352
TRobustEstimator.cxx:353
TRobustEstimator.cxx:354
TRobustEstimator.cxx:355
TRobustEstimator.cxx:356
TRobustEstimator.cxx:357
TRobustEstimator.cxx:358
TRobustEstimator.cxx:359
TRobustEstimator.cxx:360
TRobustEstimator.cxx:361
TRobustEstimator.cxx:362
TRobustEstimator.cxx:363
TRobustEstimator.cxx:364
TRobustEstimator.cxx:365
TRobustEstimator.cxx:366
TRobustEstimator.cxx:367
TRobustEstimator.cxx:368
TRobustEstimator.cxx:369
TRobustEstimator.cxx:370
TRobustEstimator.cxx:371
TRobustEstimator.cxx:372
TRobustEstimator.cxx:373
TRobustEstimator.cxx:374
TRobustEstimator.cxx:375
TRobustEstimator.cxx:376
TRobustEstimator.cxx:377
TRobustEstimator.cxx:378
TRobustEstimator.cxx:379
TRobustEstimator.cxx:380
TRobustEstimator.cxx:381
TRobustEstimator.cxx:382
TRobustEstimator.cxx:383
TRobustEstimator.cxx:384
TRobustEstimator.cxx:385
TRobustEstimator.cxx:386
TRobustEstimator.cxx:387
TRobustEstimator.cxx:388
TRobustEstimator.cxx:389
TRobustEstimator.cxx:390
TRobustEstimator.cxx:391
TRobustEstimator.cxx:392
TRobustEstimator.cxx:393
TRobustEstimator.cxx:394
TRobustEstimator.cxx:395
TRobustEstimator.cxx:396
TRobustEstimator.cxx:397
TRobustEstimator.cxx:398
TRobustEstimator.cxx:399
TRobustEstimator.cxx:400
TRobustEstimator.cxx:401
TRobustEstimator.cxx:402
TRobustEstimator.cxx:403
TRobustEstimator.cxx:404
TRobustEstimator.cxx:405
TRobustEstimator.cxx:406
TRobustEstimator.cxx:407
TRobustEstimator.cxx:408
TRobustEstimator.cxx:409
TRobustEstimator.cxx:410
TRobustEstimator.cxx:411
TRobustEstimator.cxx:412
TRobustEstimator.cxx:413
TRobustEstimator.cxx:414
TRobustEstimator.cxx:415
TRobustEstimator.cxx:416
TRobustEstimator.cxx:417
TRobustEstimator.cxx:418
TRobustEstimator.cxx:419
TRobustEstimator.cxx:420
TRobustEstimator.cxx:421
TRobustEstimator.cxx:422
TRobustEstimator.cxx:423
TRobustEstimator.cxx:424
TRobustEstimator.cxx:425
TRobustEstimator.cxx:426
TRobustEstimator.cxx:427
TRobustEstimator.cxx:428
TRobustEstimator.cxx:429
TRobustEstimator.cxx:430
TRobustEstimator.cxx:431
TRobustEstimator.cxx:432
TRobustEstimator.cxx:433
TRobustEstimator.cxx:434
TRobustEstimator.cxx:435
TRobustEstimator.cxx:436
TRobustEstimator.cxx:437
TRobustEstimator.cxx:438
TRobustEstimator.cxx:439
TRobustEstimator.cxx:440
TRobustEstimator.cxx:441
TRobustEstimator.cxx:442
TRobustEstimator.cxx:443
TRobustEstimator.cxx:444
TRobustEstimator.cxx:445
TRobustEstimator.cxx:446
TRobustEstimator.cxx:447
TRobustEstimator.cxx:448
TRobustEstimator.cxx:449
TRobustEstimator.cxx:450
TRobustEstimator.cxx:451
TRobustEstimator.cxx:452
TRobustEstimator.cxx:453
TRobustEstimator.cxx:454
TRobustEstimator.cxx:455
TRobustEstimator.cxx:456
TRobustEstimator.cxx:457
TRobustEstimator.cxx:458
TRobustEstimator.cxx:459
TRobustEstimator.cxx:460
TRobustEstimator.cxx:461
TRobustEstimator.cxx:462
TRobustEstimator.cxx:463
TRobustEstimator.cxx:464
TRobustEstimator.cxx:465
TRobustEstimator.cxx:466
TRobustEstimator.cxx:467
TRobustEstimator.cxx:468
TRobustEstimator.cxx:469
TRobustEstimator.cxx:470
TRobustEstimator.cxx:471
TRobustEstimator.cxx:472
TRobustEstimator.cxx:473
TRobustEstimator.cxx:474
TRobustEstimator.cxx:475
TRobustEstimator.cxx:476
TRobustEstimator.cxx:477
TRobustEstimator.cxx:478
TRobustEstimator.cxx:479
TRobustEstimator.cxx:480
TRobustEstimator.cxx:481
TRobustEstimator.cxx:482
TRobustEstimator.cxx:483
TRobustEstimator.cxx:484
TRobustEstimator.cxx:485
TRobustEstimator.cxx:486
TRobustEstimator.cxx:487
TRobustEstimator.cxx:488
TRobustEstimator.cxx:489
TRobustEstimator.cxx:490
TRobustEstimator.cxx:491
TRobustEstimator.cxx:492
TRobustEstimator.cxx:493
TRobustEstimator.cxx:494
TRobustEstimator.cxx:495
TRobustEstimator.cxx:496
TRobustEstimator.cxx:497
TRobustEstimator.cxx:498
TRobustEstimator.cxx:499
TRobustEstimator.cxx:500
TRobustEstimator.cxx:501
TRobustEstimator.cxx:502
TRobustEstimator.cxx:503
TRobustEstimator.cxx:504
TRobustEstimator.cxx:505
TRobustEstimator.cxx:506
TRobustEstimator.cxx:507
TRobustEstimator.cxx:508
TRobustEstimator.cxx:509
TRobustEstimator.cxx:510
TRobustEstimator.cxx:511
TRobustEstimator.cxx:512
TRobustEstimator.cxx:513
TRobustEstimator.cxx:514
TRobustEstimator.cxx:515
TRobustEstimator.cxx:516
TRobustEstimator.cxx:517
TRobustEstimator.cxx:518
TRobustEstimator.cxx:519
TRobustEstimator.cxx:520
TRobustEstimator.cxx:521
TRobustEstimator.cxx:522
TRobustEstimator.cxx:523
TRobustEstimator.cxx:524
TRobustEstimator.cxx:525
TRobustEstimator.cxx:526
TRobustEstimator.cxx:527
TRobustEstimator.cxx:528
TRobustEstimator.cxx:529
TRobustEstimator.cxx:530
TRobustEstimator.cxx:531
TRobustEstimator.cxx:532
TRobustEstimator.cxx:533
TRobustEstimator.cxx:534
TRobustEstimator.cxx:535
TRobustEstimator.cxx:536
TRobustEstimator.cxx:537
TRobustEstimator.cxx:538
TRobustEstimator.cxx:539
TRobustEstimator.cxx:540
TRobustEstimator.cxx:541
TRobustEstimator.cxx:542
TRobustEstimator.cxx:543
TRobustEstimator.cxx:544
TRobustEstimator.cxx:545
TRobustEstimator.cxx:546
TRobustEstimator.cxx:547
TRobustEstimator.cxx:548
TRobustEstimator.cxx:549
TRobustEstimator.cxx:550
TRobustEstimator.cxx:551
TRobustEstimator.cxx:552
TRobustEstimator.cxx:553
TRobustEstimator.cxx:554
TRobustEstimator.cxx:555
TRobustEstimator.cxx:556
TRobustEstimator.cxx:557
TRobustEstimator.cxx:558
TRobustEstimator.cxx:559
TRobustEstimator.cxx:560
TRobustEstimator.cxx:561
TRobustEstimator.cxx:562
TRobustEstimator.cxx:563
TRobustEstimator.cxx:564
TRobustEstimator.cxx:565
TRobustEstimator.cxx:566
TRobustEstimator.cxx:567
TRobustEstimator.cxx:568
TRobustEstimator.cxx:569
TRobustEstimator.cxx:570
TRobustEstimator.cxx:571
TRobustEstimator.cxx:572
TRobustEstimator.cxx:573
TRobustEstimator.cxx:574
TRobustEstimator.cxx:575
TRobustEstimator.cxx:576
TRobustEstimator.cxx:577
TRobustEstimator.cxx:578
TRobustEstimator.cxx:579
TRobustEstimator.cxx:580
TRobustEstimator.cxx:581
TRobustEstimator.cxx:582
TRobustEstimator.cxx:583
TRobustEstimator.cxx:584
TRobustEstimator.cxx:585
TRobustEstimator.cxx:586
TRobustEstimator.cxx:587
TRobustEstimator.cxx:588
TRobustEstimator.cxx:589
TRobustEstimator.cxx:590
TRobustEstimator.cxx:591
TRobustEstimator.cxx:592
TRobustEstimator.cxx:593
TRobustEstimator.cxx:594
TRobustEstimator.cxx:595
TRobustEstimator.cxx:596
TRobustEstimator.cxx:597
TRobustEstimator.cxx:598
TRobustEstimator.cxx:599
TRobustEstimator.cxx:600
TRobustEstimator.cxx:601
TRobustEstimator.cxx:602
TRobustEstimator.cxx:603
TRobustEstimator.cxx:604
TRobustEstimator.cxx:605
TRobustEstimator.cxx:606
TRobustEstimator.cxx:607
TRobustEstimator.cxx:608
TRobustEstimator.cxx:609
TRobustEstimator.cxx:610
TRobustEstimator.cxx:611
TRobustEstimator.cxx:612
TRobustEstimator.cxx:613
TRobustEstimator.cxx:614
TRobustEstimator.cxx:615
TRobustEstimator.cxx:616
TRobustEstimator.cxx:617
TRobustEstimator.cxx:618
TRobustEstimator.cxx:619
TRobustEstimator.cxx:620
TRobustEstimator.cxx:621
TRobustEstimator.cxx:622
TRobustEstimator.cxx:623
TRobustEstimator.cxx:624
TRobustEstimator.cxx:625
TRobustEstimator.cxx:626
TRobustEstimator.cxx:627
TRobustEstimator.cxx:628
TRobustEstimator.cxx:629
TRobustEstimator.cxx:630
TRobustEstimator.cxx:631
TRobustEstimator.cxx:632
TRobustEstimator.cxx:633
TRobustEstimator.cxx:634
TRobustEstimator.cxx:635
TRobustEstimator.cxx:636
TRobustEstimator.cxx:637
TRobustEstimator.cxx:638
TRobustEstimator.cxx:639
TRobustEstimator.cxx:640
TRobustEstimator.cxx:641
TRobustEstimator.cxx:642
TRobustEstimator.cxx:643
TRobustEstimator.cxx:644
TRobustEstimator.cxx:645
TRobustEstimator.cxx:646
TRobustEstimator.cxx:647
TRobustEstimator.cxx:648
TRobustEstimator.cxx:649
TRobustEstimator.cxx:650
TRobustEstimator.cxx:651
TRobustEstimator.cxx:652
TRobustEstimator.cxx:653
TRobustEstimator.cxx:654
TRobustEstimator.cxx:655
TRobustEstimator.cxx:656
TRobustEstimator.cxx:657
TRobustEstimator.cxx:658
TRobustEstimator.cxx:659
TRobustEstimator.cxx:660
TRobustEstimator.cxx:661
TRobustEstimator.cxx:662
TRobustEstimator.cxx:663
TRobustEstimator.cxx:664
TRobustEstimator.cxx:665
TRobustEstimator.cxx:666
TRobustEstimator.cxx:667
TRobustEstimator.cxx:668
TRobustEstimator.cxx:669
TRobustEstimator.cxx:670
TRobustEstimator.cxx:671
TRobustEstimator.cxx:672
TRobustEstimator.cxx:673
TRobustEstimator.cxx:674
TRobustEstimator.cxx:675
TRobustEstimator.cxx:676
TRobustEstimator.cxx:677
TRobustEstimator.cxx:678
TRobustEstimator.cxx:679
TRobustEstimator.cxx:680
TRobustEstimator.cxx:681
TRobustEstimator.cxx:682
TRobustEstimator.cxx:683
TRobustEstimator.cxx:684
TRobustEstimator.cxx:685
TRobustEstimator.cxx:686
TRobustEstimator.cxx:687
TRobustEstimator.cxx:688
TRobustEstimator.cxx:689
TRobustEstimator.cxx:690
TRobustEstimator.cxx:691
TRobustEstimator.cxx:692
TRobustEstimator.cxx:693
TRobustEstimator.cxx:694
TRobustEstimator.cxx:695
TRobustEstimator.cxx:696
TRobustEstimator.cxx:697
TRobustEstimator.cxx:698
TRobustEstimator.cxx:699
TRobustEstimator.cxx:700
TRobustEstimator.cxx:701
TRobustEstimator.cxx:702
TRobustEstimator.cxx:703
TRobustEstimator.cxx:704
TRobustEstimator.cxx:705
TRobustEstimator.cxx:706
TRobustEstimator.cxx:707
TRobustEstimator.cxx:708
TRobustEstimator.cxx:709
TRobustEstimator.cxx:710
TRobustEstimator.cxx:711
TRobustEstimator.cxx:712
TRobustEstimator.cxx:713
TRobustEstimator.cxx:714
TRobustEstimator.cxx:715
TRobustEstimator.cxx:716
TRobustEstimator.cxx:717
TRobustEstimator.cxx:718
TRobustEstimator.cxx:719
TRobustEstimator.cxx:720
TRobustEstimator.cxx:721
TRobustEstimator.cxx:722
TRobustEstimator.cxx:723
TRobustEstimator.cxx:724
TRobustEstimator.cxx:725
TRobustEstimator.cxx:726
TRobustEstimator.cxx:727
TRobustEstimator.cxx:728
TRobustEstimator.cxx:729
TRobustEstimator.cxx:730
TRobustEstimator.cxx:731
TRobustEstimator.cxx:732
TRobustEstimator.cxx:733
TRobustEstimator.cxx:734
TRobustEstimator.cxx:735
TRobustEstimator.cxx:736
TRobustEstimator.cxx:737
TRobustEstimator.cxx:738
TRobustEstimator.cxx:739
TRobustEstimator.cxx:740
TRobustEstimator.cxx:741
TRobustEstimator.cxx:742
TRobustEstimator.cxx:743
TRobustEstimator.cxx:744
TRobustEstimator.cxx:745
TRobustEstimator.cxx:746
TRobustEstimator.cxx:747
TRobustEstimator.cxx:748
TRobustEstimator.cxx:749
TRobustEstimator.cxx:750
TRobustEstimator.cxx:751
TRobustEstimator.cxx:752
TRobustEstimator.cxx:753
TRobustEstimator.cxx:754
TRobustEstimator.cxx:755
TRobustEstimator.cxx:756
TRobustEstimator.cxx:757
TRobustEstimator.cxx:758
TRobustEstimator.cxx:759
TRobustEstimator.cxx:760
TRobustEstimator.cxx:761
TRobustEstimator.cxx:762
TRobustEstimator.cxx:763
TRobustEstimator.cxx:764
TRobustEstimator.cxx:765
TRobustEstimator.cxx:766
TRobustEstimator.cxx:767
TRobustEstimator.cxx:768
TRobustEstimator.cxx:769
TRobustEstimator.cxx:770
TRobustEstimator.cxx:771
TRobustEstimator.cxx:772
TRobustEstimator.cxx:773
TRobustEstimator.cxx:774
TRobustEstimator.cxx:775
TRobustEstimator.cxx:776
TRobustEstimator.cxx:777
TRobustEstimator.cxx:778
TRobustEstimator.cxx:779
TRobustEstimator.cxx:780
TRobustEstimator.cxx:781
TRobustEstimator.cxx:782
TRobustEstimator.cxx:783
TRobustEstimator.cxx:784
TRobustEstimator.cxx:785
TRobustEstimator.cxx:786
TRobustEstimator.cxx:787
TRobustEstimator.cxx:788
TRobustEstimator.cxx:789
TRobustEstimator.cxx:790
TRobustEstimator.cxx:791
TRobustEstimator.cxx:792
TRobustEstimator.cxx:793
TRobustEstimator.cxx:794
TRobustEstimator.cxx:795
TRobustEstimator.cxx:796
TRobustEstimator.cxx:797
TRobustEstimator.cxx:798
TRobustEstimator.cxx:799
TRobustEstimator.cxx:800
TRobustEstimator.cxx:801
TRobustEstimator.cxx:802
TRobustEstimator.cxx:803
TRobustEstimator.cxx:804
TRobustEstimator.cxx:805
TRobustEstimator.cxx:806
TRobustEstimator.cxx:807
TRobustEstimator.cxx:808
TRobustEstimator.cxx:809
TRobustEstimator.cxx:810
TRobustEstimator.cxx:811
TRobustEstimator.cxx:812
TRobustEstimator.cxx:813
TRobustEstimator.cxx:814
TRobustEstimator.cxx:815
TRobustEstimator.cxx:816
TRobustEstimator.cxx:817
TRobustEstimator.cxx:818
TRobustEstimator.cxx:819
TRobustEstimator.cxx:820
TRobustEstimator.cxx:821
TRobustEstimator.cxx:822
TRobustEstimator.cxx:823
TRobustEstimator.cxx:824
TRobustEstimator.cxx:825
TRobustEstimator.cxx:826
TRobustEstimator.cxx:827
TRobustEstimator.cxx:828
TRobustEstimator.cxx:829
TRobustEstimator.cxx:830
TRobustEstimator.cxx:831
TRobustEstimator.cxx:832
TRobustEstimator.cxx:833
TRobustEstimator.cxx:834
TRobustEstimator.cxx:835
TRobustEstimator.cxx:836
TRobustEstimator.cxx:837
TRobustEstimator.cxx:838
TRobustEstimator.cxx:839
TRobustEstimator.cxx:840
TRobustEstimator.cxx:841
TRobustEstimator.cxx:842
TRobustEstimator.cxx:843
TRobustEstimator.cxx:844
TRobustEstimator.cxx:845
TRobustEstimator.cxx:846
TRobustEstimator.cxx:847
TRobustEstimator.cxx:848
TRobustEstimator.cxx:849
TRobustEstimator.cxx:850
TRobustEstimator.cxx:851
TRobustEstimator.cxx:852
TRobustEstimator.cxx:853
TRobustEstimator.cxx:854
TRobustEstimator.cxx:855
TRobustEstimator.cxx:856
TRobustEstimator.cxx:857
TRobustEstimator.cxx:858
TRobustEstimator.cxx:859
TRobustEstimator.cxx:860
TRobustEstimator.cxx:861
TRobustEstimator.cxx:862
TRobustEstimator.cxx:863
TRobustEstimator.cxx:864
TRobustEstimator.cxx:865
TRobustEstimator.cxx:866
TRobustEstimator.cxx:867
TRobustEstimator.cxx:868
TRobustEstimator.cxx:869
TRobustEstimator.cxx:870
TRobustEstimator.cxx:871
TRobustEstimator.cxx:872
TRobustEstimator.cxx:873
TRobustEstimator.cxx:874
TRobustEstimator.cxx:875
TRobustEstimator.cxx:876
TRobustEstimator.cxx:877
TRobustEstimator.cxx:878
TRobustEstimator.cxx:879
TRobustEstimator.cxx:880
TRobustEstimator.cxx:881
TRobustEstimator.cxx:882
TRobustEstimator.cxx:883
TRobustEstimator.cxx:884
TRobustEstimator.cxx:885
TRobustEstimator.cxx:886
TRobustEstimator.cxx:887
TRobustEstimator.cxx:888
TRobustEstimator.cxx:889
TRobustEstimator.cxx:890
TRobustEstimator.cxx:891
TRobustEstimator.cxx:892
TRobustEstimator.cxx:893
TRobustEstimator.cxx:894
TRobustEstimator.cxx:895
TRobustEstimator.cxx:896
TRobustEstimator.cxx:897
TRobustEstimator.cxx:898
TRobustEstimator.cxx:899
TRobustEstimator.cxx:900
TRobustEstimator.cxx:901
TRobustEstimator.cxx:902
TRobustEstimator.cxx:903
TRobustEstimator.cxx:904
TRobustEstimator.cxx:905
TRobustEstimator.cxx:906
TRobustEstimator.cxx:907
TRobustEstimator.cxx:908
TRobustEstimator.cxx:909
TRobustEstimator.cxx:910
TRobustEstimator.cxx:911
TRobustEstimator.cxx:912
TRobustEstimator.cxx:913
TRobustEstimator.cxx:914
TRobustEstimator.cxx:915
TRobustEstimator.cxx:916
TRobustEstimator.cxx:917
TRobustEstimator.cxx:918
TRobustEstimator.cxx:919
TRobustEstimator.cxx:920
TRobustEstimator.cxx:921
TRobustEstimator.cxx:922
TRobustEstimator.cxx:923
TRobustEstimator.cxx:924
TRobustEstimator.cxx:925
TRobustEstimator.cxx:926
TRobustEstimator.cxx:927
TRobustEstimator.cxx:928
TRobustEstimator.cxx:929
TRobustEstimator.cxx:930
TRobustEstimator.cxx:931
TRobustEstimator.cxx:932
TRobustEstimator.cxx:933
TRobustEstimator.cxx:934
TRobustEstimator.cxx:935
TRobustEstimator.cxx:936
TRobustEstimator.cxx:937
TRobustEstimator.cxx:938
TRobustEstimator.cxx:939
TRobustEstimator.cxx:940
TRobustEstimator.cxx:941
TRobustEstimator.cxx:942
TRobustEstimator.cxx:943
TRobustEstimator.cxx:944
TRobustEstimator.cxx:945
TRobustEstimator.cxx:946
TRobustEstimator.cxx:947
TRobustEstimator.cxx:948
TRobustEstimator.cxx:949
TRobustEstimator.cxx:950
TRobustEstimator.cxx:951
TRobustEstimator.cxx:952
TRobustEstimator.cxx:953
TRobustEstimator.cxx:954
TRobustEstimator.cxx:955
TRobustEstimator.cxx:956
TRobustEstimator.cxx:957
TRobustEstimator.cxx:958
TRobustEstimator.cxx:959
TRobustEstimator.cxx:960
TRobustEstimator.cxx:961
TRobustEstimator.cxx:962
TRobustEstimator.cxx:963
TRobustEstimator.cxx:964
TRobustEstimator.cxx:965
TRobustEstimator.cxx:966
TRobustEstimator.cxx:967
TRobustEstimator.cxx:968
TRobustEstimator.cxx:969
TRobustEstimator.cxx:970
TRobustEstimator.cxx:971
TRobustEstimator.cxx:972
TRobustEstimator.cxx:973
TRobustEstimator.cxx:974
TRobustEstimator.cxx:975
TRobustEstimator.cxx:976
TRobustEstimator.cxx:977
TRobustEstimator.cxx:978
TRobustEstimator.cxx:979
TRobustEstimator.cxx:980
TRobustEstimator.cxx:981
TRobustEstimator.cxx:982
TRobustEstimator.cxx:983
TRobustEstimator.cxx:984
TRobustEstimator.cxx:985
TRobustEstimator.cxx:986
TRobustEstimator.cxx:987
TRobustEstimator.cxx:988
TRobustEstimator.cxx:989
TRobustEstimator.cxx:990
TRobustEstimator.cxx:991
TRobustEstimator.cxx:992
TRobustEstimator.cxx:993
TRobustEstimator.cxx:994
TRobustEstimator.cxx:995
TRobustEstimator.cxx:996
TRobustEstimator.cxx:997
TRobustEstimator.cxx:998
TRobustEstimator.cxx:999
TRobustEstimator.cxx:1000
TRobustEstimator.cxx:1001
TRobustEstimator.cxx:1002
TRobustEstimator.cxx:1003
TRobustEstimator.cxx:1004
TRobustEstimator.cxx:1005
TRobustEstimator.cxx:1006
TRobustEstimator.cxx:1007
TRobustEstimator.cxx:1008
TRobustEstimator.cxx:1009
TRobustEstimator.cxx:1010
TRobustEstimator.cxx:1011
TRobustEstimator.cxx:1012
TRobustEstimator.cxx:1013
TRobustEstimator.cxx:1014
TRobustEstimator.cxx:1015
TRobustEstimator.cxx:1016
TRobustEstimator.cxx:1017
TRobustEstimator.cxx:1018
TRobustEstimator.cxx:1019
TRobustEstimator.cxx:1020
TRobustEstimator.cxx:1021
TRobustEstimator.cxx:1022
TRobustEstimator.cxx:1023
TRobustEstimator.cxx:1024
TRobustEstimator.cxx:1025
TRobustEstimator.cxx:1026
TRobustEstimator.cxx:1027
TRobustEstimator.cxx:1028
TRobustEstimator.cxx:1029
TRobustEstimator.cxx:1030
TRobustEstimator.cxx:1031
TRobustEstimator.cxx:1032
TRobustEstimator.cxx:1033
TRobustEstimator.cxx:1034
TRobustEstimator.cxx:1035
TRobustEstimator.cxx:1036
TRobustEstimator.cxx:1037
TRobustEstimator.cxx:1038
TRobustEstimator.cxx:1039
TRobustEstimator.cxx:1040
TRobustEstimator.cxx:1041
TRobustEstimator.cxx:1042
TRobustEstimator.cxx:1043
TRobustEstimator.cxx:1044
TRobustEstimator.cxx:1045
TRobustEstimator.cxx:1046
TRobustEstimator.cxx:1047
TRobustEstimator.cxx:1048
TRobustEstimator.cxx:1049
TRobustEstimator.cxx:1050
TRobustEstimator.cxx:1051
TRobustEstimator.cxx:1052
TRobustEstimator.cxx:1053
TRobustEstimator.cxx:1054
TRobustEstimator.cxx:1055
TRobustEstimator.cxx:1056
TRobustEstimator.cxx:1057
TRobustEstimator.cxx:1058
TRobustEstimator.cxx:1059
TRobustEstimator.cxx:1060
TRobustEstimator.cxx:1061
TRobustEstimator.cxx:1062
TRobustEstimator.cxx:1063
TRobustEstimator.cxx:1064
TRobustEstimator.cxx:1065
TRobustEstimator.cxx:1066
TRobustEstimator.cxx:1067
TRobustEstimator.cxx:1068
TRobustEstimator.cxx:1069
TRobustEstimator.cxx:1070
TRobustEstimator.cxx:1071
TRobustEstimator.cxx:1072
TRobustEstimator.cxx:1073
TRobustEstimator.cxx:1074
TRobustEstimator.cxx:1075
TRobustEstimator.cxx:1076
TRobustEstimator.cxx:1077
TRobustEstimator.cxx:1078
TRobustEstimator.cxx:1079
TRobustEstimator.cxx:1080
TRobustEstimator.cxx:1081
TRobustEstimator.cxx:1082
TRobustEstimator.cxx:1083
TRobustEstimator.cxx:1084
TRobustEstimator.cxx:1085
TRobustEstimator.cxx:1086
TRobustEstimator.cxx:1087
TRobustEstimator.cxx:1088
TRobustEstimator.cxx:1089
TRobustEstimator.cxx:1090
TRobustEstimator.cxx:1091
TRobustEstimator.cxx:1092
TRobustEstimator.cxx:1093
TRobustEstimator.cxx:1094
TRobustEstimator.cxx:1095
TRobustEstimator.cxx:1096
TRobustEstimator.cxx:1097
TRobustEstimator.cxx:1098
TRobustEstimator.cxx:1099
TRobustEstimator.cxx:1100
TRobustEstimator.cxx:1101
TRobustEstimator.cxx:1102
TRobustEstimator.cxx:1103
TRobustEstimator.cxx:1104
TRobustEstimator.cxx:1105
TRobustEstimator.cxx:1106
TRobustEstimator.cxx:1107
TRobustEstimator.cxx:1108
TRobustEstimator.cxx:1109
TRobustEstimator.cxx:1110
TRobustEstimator.cxx:1111
TRobustEstimator.cxx:1112
TRobustEstimator.cxx:1113
TRobustEstimator.cxx:1114
TRobustEstimator.cxx:1115
TRobustEstimator.cxx:1116
TRobustEstimator.cxx:1117
TRobustEstimator.cxx:1118
TRobustEstimator.cxx:1119
TRobustEstimator.cxx:1120
TRobustEstimator.cxx:1121
TRobustEstimator.cxx:1122
TRobustEstimator.cxx:1123
TRobustEstimator.cxx:1124
TRobustEstimator.cxx:1125
TRobustEstimator.cxx:1126
TRobustEstimator.cxx:1127
TRobustEstimator.cxx:1128
TRobustEstimator.cxx:1129
TRobustEstimator.cxx:1130
TRobustEstimator.cxx:1131
TRobustEstimator.cxx:1132
TRobustEstimator.cxx:1133
TRobustEstimator.cxx:1134
TRobustEstimator.cxx:1135
TRobustEstimator.cxx:1136
TRobustEstimator.cxx:1137
TRobustEstimator.cxx:1138
TRobustEstimator.cxx:1139
TRobustEstimator.cxx:1140
TRobustEstimator.cxx:1141
TRobustEstimator.cxx:1142
TRobustEstimator.cxx:1143
TRobustEstimator.cxx:1144
TRobustEstimator.cxx:1145
TRobustEstimator.cxx:1146
TRobustEstimator.cxx:1147
TRobustEstimator.cxx:1148
TRobustEstimator.cxx:1149
TRobustEstimator.cxx:1150
TRobustEstimator.cxx:1151
TRobustEstimator.cxx:1152
TRobustEstimator.cxx:1153
TRobustEstimator.cxx:1154
TRobustEstimator.cxx:1155
TRobustEstimator.cxx:1156
TRobustEstimator.cxx:1157
TRobustEstimator.cxx:1158
TRobustEstimator.cxx:1159
TRobustEstimator.cxx:1160
TRobustEstimator.cxx:1161
TRobustEstimator.cxx:1162
TRobustEstimator.cxx:1163
TRobustEstimator.cxx:1164
TRobustEstimator.cxx:1165
TRobustEstimator.cxx:1166
TRobustEstimator.cxx:1167
TRobustEstimator.cxx:1168
TRobustEstimator.cxx:1169
TRobustEstimator.cxx:1170
TRobustEstimator.cxx:1171
TRobustEstimator.cxx:1172
TRobustEstimator.cxx:1173
TRobustEstimator.cxx:1174
TRobustEstimator.cxx:1175
TRobustEstimator.cxx:1176
TRobustEstimator.cxx:1177
TRobustEstimator.cxx:1178
TRobustEstimator.cxx:1179
TRobustEstimator.cxx:1180
TRobustEstimator.cxx:1181
TRobustEstimator.cxx:1182
TRobustEstimator.cxx:1183
TRobustEstimator.cxx:1184
TRobustEstimator.cxx:1185
TRobustEstimator.cxx:1186
TRobustEstimator.cxx:1187
TRobustEstimator.cxx:1188
TRobustEstimator.cxx:1189
TRobustEstimator.cxx:1190
TRobustEstimator.cxx:1191
TRobustEstimator.cxx:1192
TRobustEstimator.cxx:1193
TRobustEstimator.cxx:1194
TRobustEstimator.cxx:1195
TRobustEstimator.cxx:1196
TRobustEstimator.cxx:1197
TRobustEstimator.cxx:1198
TRobustEstimator.cxx:1199
TRobustEstimator.cxx:1200
TRobustEstimator.cxx:1201
TRobustEstimator.cxx:1202
TRobustEstimator.cxx:1203
TRobustEstimator.cxx:1204
TRobustEstimator.cxx:1205
TRobustEstimator.cxx:1206
TRobustEstimator.cxx:1207
TRobustEstimator.cxx:1208
TRobustEstimator.cxx:1209
TRobustEstimator.cxx:1210
TRobustEstimator.cxx:1211
TRobustEstimator.cxx:1212
TRobustEstimator.cxx:1213
TRobustEstimator.cxx:1214
TRobustEstimator.cxx:1215
TRobustEstimator.cxx:1216
TRobustEstimator.cxx:1217
TRobustEstimator.cxx:1218
TRobustEstimator.cxx:1219
TRobustEstimator.cxx:1220
TRobustEstimator.cxx:1221
TRobustEstimator.cxx:1222
TRobustEstimator.cxx:1223
TRobustEstimator.cxx:1224
TRobustEstimator.cxx:1225
TRobustEstimator.cxx:1226
TRobustEstimator.cxx:1227
TRobustEstimator.cxx:1228
TRobustEstimator.cxx:1229
TRobustEstimator.cxx:1230
TRobustEstimator.cxx:1231
TRobustEstimator.cxx:1232
TRobustEstimator.cxx:1233
TRobustEstimator.cxx:1234
TRobustEstimator.cxx:1235
TRobustEstimator.cxx:1236
TRobustEstimator.cxx:1237
TRobustEstimator.cxx:1238
TRobustEstimator.cxx:1239
TRobustEstimator.cxx:1240
TRobustEstimator.cxx:1241
TRobustEstimator.cxx:1242
TRobustEstimator.cxx:1243
TRobustEstimator.cxx:1244
TRobustEstimator.cxx:1245
TRobustEstimator.cxx:1246
TRobustEstimator.cxx:1247
TRobustEstimator.cxx:1248
TRobustEstimator.cxx:1249
TRobustEstimator.cxx:1250
TRobustEstimator.cxx:1251
TRobustEstimator.cxx:1252
TRobustEstimator.cxx:1253
TRobustEstimator.cxx:1254
TRobustEstimator.cxx:1255
TRobustEstimator.cxx:1256
TRobustEstimator.cxx:1257
TRobustEstimator.cxx:1258
TRobustEstimator.cxx:1259
TRobustEstimator.cxx:1260
TRobustEstimator.cxx:1261
TRobustEstimator.cxx:1262
TRobustEstimator.cxx:1263
TRobustEstimator.cxx:1264
TRobustEstimator.cxx:1265
TRobustEstimator.cxx:1266
TRobustEstimator.cxx:1267
TRobustEstimator.cxx:1268
TRobustEstimator.cxx:1269
TRobustEstimator.cxx:1270
TRobustEstimator.cxx:1271
TRobustEstimator.cxx:1272
TRobustEstimator.cxx:1273
TRobustEstimator.cxx:1274
TRobustEstimator.cxx:1275
TRobustEstimator.cxx:1276
TRobustEstimator.cxx:1277
TRobustEstimator.cxx:1278
TRobustEstimator.cxx:1279
TRobustEstimator.cxx:1280
TRobustEstimator.cxx:1281
TRobustEstimator.cxx:1282
TRobustEstimator.cxx:1283
TRobustEstimator.cxx:1284
TRobustEstimator.cxx:1285
TRobustEstimator.cxx:1286
TRobustEstimator.cxx:1287
TRobustEstimator.cxx:1288
TRobustEstimator.cxx:1289
TRobustEstimator.cxx:1290
TRobustEstimator.cxx:1291
TRobustEstimator.cxx:1292
TRobustEstimator.cxx:1293
TRobustEstimator.cxx:1294
TRobustEstimator.cxx:1295
TRobustEstimator.cxx:1296
TRobustEstimator.cxx:1297
TRobustEstimator.cxx:1298
TRobustEstimator.cxx:1299
TRobustEstimator.cxx:1300
TRobustEstimator.cxx:1301
TRobustEstimator.cxx:1302
TRobustEstimator.cxx:1303
TRobustEstimator.cxx:1304
TRobustEstimator.cxx:1305
TRobustEstimator.cxx:1306
TRobustEstimator.cxx:1307
TRobustEstimator.cxx:1308
TRobustEstimator.cxx:1309
TRobustEstimator.cxx:1310
TRobustEstimator.cxx:1311
TRobustEstimator.cxx:1312
TRobustEstimator.cxx:1313
TRobustEstimator.cxx:1314
TRobustEstimator.cxx:1315
TRobustEstimator.cxx:1316
TRobustEstimator.cxx:1317
TRobustEstimator.cxx:1318
TRobustEstimator.cxx:1319
TRobustEstimator.cxx:1320
TRobustEstimator.cxx:1321
TRobustEstimator.cxx:1322