Removing warnings
[u/mrichter/AliRoot.git] / RALICE / AliSample.cxx
CommitLineData
4c039060 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
f531a546 16// $Id$
4c039060 17
959fbac5 18///////////////////////////////////////////////////////////////////////////
19// Class AliSample
6516b62d 20// Perform statistics on various multi-dimensional data samples.
959fbac5 21// A data sample can be filled using the "Enter" and/or "Remove" functions,
22// whereas the "Reset" function resets the complete sample to 'empty'.
23// The info which can be extracted from a certain data sample are the
24// sum, mean, variance, sigma, covariance and correlation.
84bb7c66 25// The "Data" function provides all statistics data for a certain sample.
959fbac5 26// The variables for which these stat. parameters have to be calculated
27// are indicated by the index of the variable which is passed as an
28// argument to the various member functions.
29// The index convention for a data point (x,y) is : x=1 y=2
30//
31// Example :
32// ---------
33// For an AliSample s a data point (x,y) can be entered as s.Enter(x,y) and
34// the mean_x can be obtained as s.GetMean(1) whereas the mean_y is obtained
35// via s.GetMean(2).
36// The correlation between x and y is available via s.GetCor(1,2).
84bb7c66 37// The x-statistics are obtained via s.Data(1), y-statistics via s.Data(2),
38// and the covariance and correlation between x and y via s.Data(1,2).
39// All statistics of a sample are obtained via s.Data().
959fbac5 40//
41//--- Author: Nick van Eijndhoven 30-mar-1996 CERN Geneva
f531a546 42//- Modified: NvE $Date$ UU-SAP Utrecht
959fbac5 43///////////////////////////////////////////////////////////////////////////
44
d88f97cc 45#include "AliSample.h"
c72198f1 46#include "Riostream.h"
d88f97cc 47
6516b62d 48ClassImp(AliSample) // Class implementation to enable ROOT I/O
49
d88f97cc 50AliSample::AliSample()
51{
52// Creation of an Aliample object and resetting the statistics values
53// The dimension is initialised to maximum
54 fDim=fMaxdim;
55 fNames[0]='X';
56 fNames[1]='Y';
57 fNames[2]='Z';
58 fN=0;
25eefd00 59 fRemove=0;
219e9b7e 60 fStore=0;
61 fX=0;
62 fY=0;
63 fZ=0;
64 fArr=0;
d88f97cc 65 Reset();
66}
67///////////////////////////////////////////////////////////////////////////
68AliSample::~AliSample()
69{
70// Default destructor
219e9b7e 71 if (fX)
72 {
73 delete fX;
74 fX=0;
75 }
76 if (fY)
77 {
78 delete fY;
79 fY=0;
80 }
81 if (fZ)
82 {
83 delete fZ;
84 fZ=0;
85 }
86 if (fArr)
87 {
88 delete fArr;
89 fArr=0;
90 }
d88f97cc 91}
92///////////////////////////////////////////////////////////////////////////
93void AliSample::Reset()
94{
95// Resetting the statistics values for a certain Sample object
219e9b7e 96// Dimension and storage flag are NOT changed
d88f97cc 97 fN=0;
25eefd00 98 fRemove=0;
d88f97cc 99 for (Int_t i=0; i<fDim; i++)
100 {
101 fSum[i]=0.;
102 fMean[i]=0.;
103 fVar[i]=0.;
104 fSigma[i]=0.;
25eefd00 105 fMin[i]=0;
106 fMax[i]=0;
d88f97cc 107 for (Int_t j=0; j<fDim; j++)
108 {
109 fSum2[i][j]=0.;
110 fCov[i][j]=0.;
111 fCor[i][j]=0.;
112 }
113 }
219e9b7e 114
115 // Set storage arrays to initial size
116 if (fX) fX->Set(10);
117 if (fY) fY->Set(10);
118 if (fZ) fZ->Set(10);
d88f97cc 119}
120///////////////////////////////////////////////////////////////////////////
121void AliSample::Enter(Float_t x)
122{
123// Entering a value into a 1-dim. sample
124// In case of first entry the dimension is set to 1
125 if (fN == 0)
126 {
127 fDim=1;
128 fNames[0]='X';
129 fNames[1]='-';
130 fNames[2]='-';
131 }
132 if (fDim != 1)
133 {
134 cout << " *AliSample::enter* Error : Not a 1-dim sample." << endl;
135 }
136 else
137 {
138 fN+=1;
139 fSum[0]+=x;
140 fSum2[0][0]+=x*x;
219e9b7e 141
25eefd00 142 if (fN==1)
143 {
144 fMin[0]=x;
145 fMax[0]=x;
146 }
147 else
148 {
149 if (x<fMin[0]) fMin[0]=x;
150 if (x>fMax[0]) fMax[0]=x;
151 }
152
219e9b7e 153 // Store all entered data when storage mode has been selected
154 if (fStore)
155 {
156 if (!fX) fX=new TArrayF(10);
157 if (fX->GetSize() < fN) fX->Set(fN+10);
158 fX->AddAt(x,fN-1);
159 }
160
161 // Compute the various statistics
d88f97cc 162 Compute();
163 }
164}
165///////////////////////////////////////////////////////////////////////////
166void AliSample::Remove(Float_t x)
167{
168// Removing a value from a 1-dim. sample
219e9b7e 169
170 if (!fN) return;
171
d88f97cc 172 if (fDim != 1)
173 {
174 cout << " *AliSample::remove* Error : Not a 1-dim sample." << endl;
175 }
176 else
177 {
25eefd00 178 fRemove=1;
d88f97cc 179 fN-=1;
180 fSum[0]-=x;
181 fSum2[0][0]-=x*x;
219e9b7e 182
183 // Remove data entry from the storage
184 if (fStore && fX)
185 {
186 Float_t val=0;
187 for (Int_t i=0; i<=fN; i++)
188 {
189 val=fX->At(i);
190 if (fabs(x-val)>1.e-10) continue;
191
192 for (Int_t j=i+1; j<=fN; j++)
193 {
194 val=fX->At(j);
195 fX->AddAt(val,j-1);
196 }
197 }
198 }
199
200 // Compute the various statistics
d88f97cc 201 Compute();
202 }
203}
204///////////////////////////////////////////////////////////////////////////
205void AliSample::Enter(Float_t x,Float_t y)
206{
207// Entering a pair (x,y) into a 2-dim. sample
208// In case of first entry the dimension is set to 2
209 if (fN == 0)
210 {
211 fDim=2;
212 fNames[0]='X';
213 fNames[1]='Y';
214 fNames[2]='-';
215 }
216 if (fDim != 2)
217 {
218 cout << " *AliSample::enter* Error : Not a 2-dim sample." << endl;
219 }
220 else
221 {
222 fN+=1;
223 fSum[0]+=x;
224 fSum[1]+=y;
225 fSum2[0][0]+=x*x;
226 fSum2[0][1]+=x*y;
227 fSum2[1][0]+=y*x;
228 fSum2[1][1]+=y*y;
219e9b7e 229
25eefd00 230 if (fN==1)
231 {
232 fMin[0]=x;
233 fMax[0]=x;
234 fMin[1]=y;
235 fMax[1]=y;
236 }
237 else
238 {
239 if (x<fMin[0]) fMin[0]=x;
240 if (x>fMax[0]) fMax[0]=x;
241 if (y<fMin[1]) fMin[1]=y;
242 if (y>fMax[1]) fMax[1]=y;
243 }
244
219e9b7e 245 // Store all entered data when storage mode has been selected
246 if (fStore)
247 {
248 if (!fX) fX=new TArrayF(10);
249 if (fX->GetSize() < fN) fX->Set(fN+10);
250 fX->AddAt(x,fN-1);
251 if (!fY) fY=new TArrayF(10);
252 if (fY->GetSize() < fN) fY->Set(fN+10);
253 fY->AddAt(y,fN-1);
254 }
255
256 // Compute the various statistics
d88f97cc 257 Compute();
258 }
259}
260///////////////////////////////////////////////////////////////////////////
261void AliSample::Remove(Float_t x,Float_t y)
262{
263// Removing a pair (x,y) from a 2-dim. sample
219e9b7e 264
265 if (!fN) return;
266
d88f97cc 267 if (fDim != 2)
268 {
269 cout << " *AliSample::remove* Error : Not a 2-dim sample." << endl;
270 }
271 else
272 {
25eefd00 273 fRemove=1;
d88f97cc 274 fN-=1;
275 fSum[0]-=x;
276 fSum[1]-=y;
277 fSum2[0][0]-=x*x;
278 fSum2[0][1]-=x*y;
279 fSum2[1][0]-=y*x;
280 fSum2[1][1]-=y*y;
219e9b7e 281
282 // Remove data entry from the storage
283 if (fStore && fX && fY)
284 {
285 Float_t val=0;
286 for (Int_t i=0; i<=fN; i++)
287 {
288 val=fX->At(i);
289 if (fabs(x-val)>1.e-10) continue;
290 val=fY->At(i);
291 if (fabs(y-val)>1.e-10) continue;
292
293 for (Int_t j=i+1; j<=fN; j++)
294 {
295 val=fX->At(j);
296 fX->AddAt(val,j-1);
297 val=fY->At(j);
298 fY->AddAt(val,j-1);
299 }
300 }
301 }
302
303 // Compute the various statistics
d88f97cc 304 Compute();
305 }
306}
307///////////////////////////////////////////////////////////////////////////
308void AliSample::Enter(Float_t x,Float_t y,Float_t z)
309{
310// Entering a set (x,y,z) into a 3-dim. sample
311// In case of first entry the dimension is set to 3
312 if (fN == 0)
313 {
314 fDim=3;
315 fNames[0]='X';
316 fNames[1]='Y';
317 fNames[2]='Z';
318 }
319 if (fDim != 3)
320 {
321 cout << " *AliSample::enter* Error : Not a 3-dim sample." << endl;
322 }
323 else
324 {
325 fN+=1;
326 fSum[0]+=x;
327 fSum[1]+=y;
328 fSum[2]+=z;
329 fSum2[0][0]+=x*x;
330 fSum2[0][1]+=x*y;
331 fSum2[0][2]+=x*z;
332 fSum2[1][0]+=y*x;
333 fSum2[1][1]+=y*y;
334 fSum2[1][2]+=y*z;
335 fSum2[2][0]+=z*x;
336 fSum2[2][1]+=z*y;
337 fSum2[2][2]+=z*z;
219e9b7e 338
25eefd00 339 if (fN==1)
340 {
341 fMin[0]=x;
342 fMax[0]=x;
343 fMin[1]=y;
344 fMax[1]=y;
345 fMin[2]=z;
346 fMax[2]=z;
347 }
348 else
349 {
350 if (x<fMin[0]) fMin[0]=x;
351 if (x>fMax[0]) fMax[0]=x;
352 if (y<fMin[1]) fMin[1]=y;
353 if (y>fMax[1]) fMax[1]=y;
354 if (z<fMin[2]) fMin[2]=z;
355 if (z>fMax[2]) fMax[2]=z;
356 }
357
219e9b7e 358 // Store all entered data when storage mode has been selected
359 if (fStore)
360 {
361 if (!fX) fX=new TArrayF(10);
362 if (fX->GetSize() < fN) fX->Set(fN+10);
363 fX->AddAt(x,fN-1);
364 if (!fY) fY=new TArrayF(10);
365 if (fY->GetSize() < fN) fY->Set(fN+10);
366 fY->AddAt(y,fN-1);
367 if (!fZ) fZ=new TArrayF(10);
368 if (fZ->GetSize() < fN) fZ->Set(fN+10);
369 fZ->AddAt(z,fN-1);
370 }
371
372 // Compute the various statistics
d88f97cc 373 Compute();
374 }
375}
376///////////////////////////////////////////////////////////////////////////
377void AliSample::Remove(Float_t x,Float_t y,Float_t z)
378{
379// Removing a set (x,y,z) from a 3-dim. sample
219e9b7e 380
381 if (!fN) return;
382
d88f97cc 383 if (fDim != 3)
384 {
385 cout << " *AliSample::remove* Error : Not a 3-dim sample." << endl;
386 }
387 else
388 {
25eefd00 389 fRemove=1;
d88f97cc 390 fN-=1;
391 fSum[0]-=x;
392 fSum[1]-=y;
393 fSum[2]-=z;
394 fSum2[0][0]-=x*x;
395 fSum2[0][1]-=x*y;
396 fSum2[0][2]-=x*z;
397 fSum2[1][0]-=y*x;
398 fSum2[1][1]-=y*y;
399 fSum2[1][2]-=y*z;
400 fSum2[2][0]-=z*x;
401 fSum2[2][1]-=z*y;
402 fSum2[2][2]-=z*z;
219e9b7e 403
404 // Remove data entry from the storage
405 if (fStore && fX && fY && fZ)
406 {
407 Float_t val=0;
408 for (Int_t i=0; i<=fN; i++)
409 {
410 val=fX->At(i);
411 if (fabs(x-val)>1.e-10) continue;
412 val=fY->At(i);
413 if (fabs(y-val)>1.e-10) continue;
414 val=fZ->At(i);
415 if (fabs(z-val)>1.e-10) continue;
416
417 for (Int_t j=i+1; j<=fN; j++)
418 {
419 val=fX->At(j);
420 fX->AddAt(val,j-1);
421 val=fY->At(j);
422 fY->AddAt(val,j-1);
423 val=fZ->At(j);
424 fZ->AddAt(val,j-1);
425 }
426 }
427 }
428
429 // Compute the various statistics
d88f97cc 430 Compute();
431 }
432}
433///////////////////////////////////////////////////////////////////////////
434void AliSample::Compute()
435{
436// Computation of the various statistical values
437// after each entering or removing action on a certain sample
438 Float_t rn=fN;
439 for (Int_t k=0; k<fDim; k++)
440 {
441 fMean[k]=fSum[k]/rn;
442 fVar[k]=(fSum2[k][k]/rn)-(fMean[k]*fMean[k]);
443 if (fVar[k] < 0.) fVar[k]=0.;
444 fSigma[k]=sqrt(fVar[k]);
445 }
446 for (Int_t i=0; i<fDim; i++)
447 {
448 for (Int_t j=0; j<fDim; j++)
449 {
450 fCov[i][j]=(fSum2[i][j]/rn)-(fMean[i]*fMean[j]);
451 Float_t sigij=fSigma[i]*fSigma[j];
452 if (sigij != 0.) fCor[i][j]=fCov[i][j]/sigij;
453 }
454 }
455}
456///////////////////////////////////////////////////////////////////////////
261c0caf 457Int_t AliSample::GetDimension() const
d88f97cc 458{
459// Provide the dimension of a certain sample
460 return fDim;
461}
462///////////////////////////////////////////////////////////////////////////
261c0caf 463Int_t AliSample::GetN() const
d88f97cc 464{
465// Provide the number of entries of a certain sample
466 return fN;
467}
468///////////////////////////////////////////////////////////////////////////
261c0caf 469Float_t AliSample::GetSum(Int_t i) const
d88f97cc 470{
471// Provide the sum of a certain variable
472 if (fDim < i)
473 {
474 cout << " *AliSample::sum* Error : Dimension less than " << i << endl;
475 return 0.;
476 }
477 else
478 {
479 return fSum[i-1];
480 }
481}
482///////////////////////////////////////////////////////////////////////////
261c0caf 483Float_t AliSample::GetMean(Int_t i) const
d88f97cc 484{
485// Provide the mean of a certain variable
486 if (fDim < i)
487 {
488 cout << " *AliSample::mean* Error : Dimension less than " << i << endl;
489 return 0.;
490 }
491 else
492 {
493 return fMean[i-1];
494 }
495}
496///////////////////////////////////////////////////////////////////////////
261c0caf 497Float_t AliSample::GetVar(Int_t i) const
d88f97cc 498{
499// Provide the variance of a certain variable
500 if (fDim < i)
501 {
502 cout << " *AliSample::var* Error : Dimension less than " << i << endl;
503 return 0.;
504 }
505 else
506 {
507 return fVar[i-1];
508 }
509}
510///////////////////////////////////////////////////////////////////////////
261c0caf 511Float_t AliSample::GetSigma(Int_t i) const
d88f97cc 512{
513// Provide the standard deviation of a certain variable
514 if (fDim < i)
515 {
516 cout << " *AliSample::sigma* Error : Dimension less than " << i << endl;
517 return 0.;
518 }
519 else
520 {
521 return fSigma[i-1];
522 }
523}
524///////////////////////////////////////////////////////////////////////////
261c0caf 525Float_t AliSample::GetCov(Int_t i,Int_t j) const
d88f97cc 526{
527// Provide the covariance between variables i and j
528 if ((fDim < i) || (fDim < j))
529 {
530 Int_t k=i;
531 if (j > i) k=j;
532 cout << " *AliSample::cov* Error : Dimension less than " << k << endl;
533 return 0.;
534 }
535 else
536 {
537 return fCov[i-1][j-1];
538 }
539}
540///////////////////////////////////////////////////////////////////////////
261c0caf 541Float_t AliSample::GetCor(Int_t i,Int_t j) const
d88f97cc 542{
543// Provide the correlation between variables i and j
544 if ((fDim < i) || (fDim < j))
545 {
546 Int_t k=i;
547 if (j > i) k=j;
548 cout << " *AliSample::cor* Error : Dimension less than " << k << endl;
549 return 0.;
550 }
551 else
552 {
553 return fCor[i-1][j-1];
554 }
555}
556///////////////////////////////////////////////////////////////////////////
219e9b7e 557void AliSample::Data()
d88f97cc 558{
559// Printing of statistics of all variables
560 for (Int_t i=0; i<fDim; i++)
561 {
562 cout << " " << fNames[i] << " : N = " << fN;
563 cout << " Sum = " << fSum[i] << " Mean = " << fMean[i];
219e9b7e 564 cout << " Var = " << fVar[i] << " Sigma = " << fSigma[i];
35e721bf 565 if (fStore)
566 {
567 cout << endl;
568 cout << " Minimum = " << GetMinimum(i+1);
569 cout << " Maximum = " << GetMaximum(i+1);
570 cout << " Median = " << GetMedian(i+1);
571 }
219e9b7e 572 cout << endl;
d88f97cc 573 }
574}
575///////////////////////////////////////////////////////////////////////////
219e9b7e 576void AliSample::Data(Int_t i)
d88f97cc 577{
578// Printing of statistics of ith variable
579 if (fDim < i)
580 {
84bb7c66 581 cout << " *AliSample::Data(i)* Error : Dimension less than " << i << endl;
d88f97cc 582 }
583 else
584 {
585 cout << " " << fNames[i-1] << " : N = " << fN;
586 cout << " Sum = " << fSum[i-1] << " Mean = " << fMean[i-1];
219e9b7e 587 cout << " Var = " << fVar[i-1] << " Sigma = " << fSigma[i-1];
35e721bf 588 if (fStore)
589 {
590 cout << endl;
591 cout << " Minimum = " << GetMinimum(i);
592 cout << " Maximum = " << GetMaximum(i);
593 cout << " Median = " << GetMedian(i);
594 }
219e9b7e 595 cout << endl;
d88f97cc 596 }
597}
598///////////////////////////////////////////////////////////////////////////
261c0caf 599void AliSample::Data(Int_t i,Int_t j) const
d88f97cc 600{
601// Printing of covariance and correlation between variables i and j
602 if ((fDim < i) || (fDim < j))
603 {
604 Int_t k=i;
605 if (j > i) k=j;
84bb7c66 606 cout << " *AliSample::Data(i,j)* Error : Dimension less than " << k << endl;
d88f97cc 607 }
608 else
609 {
610 cout << " " << fNames[i-1] << "-" << fNames[j-1] << " correlation :";
611 cout << " Cov. = " << fCov[i-1][j-1] << " Cor. = " << fCor[i-1][j-1] << endl;
612 }
613}
614///////////////////////////////////////////////////////////////////////////
219e9b7e 615void AliSample::SetStoreMode(Int_t mode)
616{
617// Set storage mode for all entered data.
618//
619// mode = 0 : Entered data will not be stored
620// 1 : All data will be stored as entered
621//
622// By default the storage mode is set to 0 in the constructor of this class.
623// The default at invokation of this memberfunction is mode=1.
624//
625// For normal statistics evaluation (e.g. mean, sigma, covariance etc...)
626// storage of entered data is not needed. This is the default mode
627// of operation and is the most efficient w.r.t. cpu time and memory.
35e721bf 628// However, when calculation of a median, minimum or maximum is required,
90a99772 629// then the data storage mode has be activated, unless the statistics
630// are obtained from a specified input histogram.
219e9b7e 631//
632// Note : Activation of storage mode can only be performed before the
633// first data item is entered.
634
635 if (fN)
636 {
637 cout << " *AliSample::SetStore* Storage mode can only be set before first data." << endl;
638 }
639 else
640 {
641 if (mode==0 || mode==1) fStore=mode;
642 }
643}
644///////////////////////////////////////////////////////////////////////////
645Int_t AliSample::GetStoreMode() const
646{
647// Provide the storage mode
648 return fStore;
649}
650///////////////////////////////////////////////////////////////////////////
651Float_t AliSample::GetMedian(Int_t i)
652{
35e721bf 653// Provide the median of a certain variable.
654// For this functionality the storage mode has to be activated.
90a99772 655//
656// Note : For large datasets it is more efficient to determine the median
657// via the specification of a histogram.
658// See the other GetMedian memberfunction for details.
219e9b7e 659
660 if (fDim < i)
661 {
35e721bf 662 cout << " *AliSample::GetMedian* Error : Dimension less than " << i << endl;
219e9b7e 663 return 0;
664 }
665
666 if (!fStore)
667 {
668 cout << " *AliSample::GetMedian* Error : Storage of data entries was not activated." << endl;
669 return 0;
670 }
671
35e721bf 672 if (fN<=0) return 0;
673
674 Float_t median=0;
675
676 if (fN==1)
677 {
678 if (i==1) median=fX->At(0);
679 if (i==2) median=fY->At(0);
680 if (i==3) median=fZ->At(0);
681 return median;
682 }
683
219e9b7e 684 // Prepare temp. array to hold the ordered values
685 if (!fArr)
686 {
687 fArr=new TArrayF(fN);
688 }
689 else
690 {
691 if (fArr->GetSize() < fN) fArr->Set(fN);
692 }
693
694 // Order the values of the specified variable
695 Float_t val=0;
696 Int_t iadd=0;
697 for (Int_t j=0; j<fN; j++)
698 {
699 if (i==1) val=fX->At(j);
700 if (i==2) val=fY->At(j);
701 if (i==3) val=fZ->At(j);
702
703 iadd=0;
704 if (j==0)
705 {
706 fArr->AddAt(val,j);
707 iadd=1;
708 }
709 else
710 {
711 for (Int_t k=0; k<j; k++)
712 {
713 if (val>=fArr->At(k)) continue;
714 // Put value in between the existing ones
715 for (Int_t m=j-1; m>=k; m--)
716 {
717 fArr->AddAt(fArr->At(m),m+1);
718 }
719 fArr->AddAt(val,k);
720 iadd=1;
721 break;
722 }
723
724 if (!iadd)
725 {
726 fArr->AddAt(val,j);
727 }
728 }
729 }
730
35e721bf 731 median=0;
219e9b7e 732 Int_t index=fN/2;
733 if (fN%2) // Odd number of entries
734 {
735 median=fArr->At(index);
736 }
737 else // Even number of entries
738 {
739 median=(fArr->At(index-1)+fArr->At(index))/2.;
740 }
741 return median;
742}
743///////////////////////////////////////////////////////////////////////////
25eefd00 744Float_t AliSample::GetSpread(Int_t i)
745{
746// Provide the spread w.r.t. the median of a certain variable.
747// The spread is defined as the average of |median-val(i)|.
748// For this functionality the storage mode has to be activated.
90a99772 749//
750// Note : For large datasets it is more efficient to determine the spread
751// via the specification of a histogram.
752// See the other GetSpread memberfunction for details.
25eefd00 753
754 if (fDim < i)
755 {
756 cout << " *AliSample::GetSpread* Error : Dimension less than " << i << endl;
757 return 0;
758 }
759
760 if (!fStore)
761 {
762 cout << " *AliSample::GetSpread* Error : Storage of data entries was not activated." << endl;
763 return 0;
764 }
765
766 if (fN<=1) return 0;
767
768 Float_t median=GetMedian(i);
769
770 Float_t spread=0;
771 for (Int_t j=0; j<fN; j++)
772 {
773 spread+=fabs(median-(fArr->At(j)));
774 }
775
776 spread=spread/float(fN);
777
778 return spread;
779}
780///////////////////////////////////////////////////////////////////////////
35e721bf 781Float_t AliSample::GetMinimum(Int_t i) const
782{
783// Provide the minimum value of a certain variable.
25eefd00 784// In case entries have been removed from the sample, a correct value can
785// only be obtained if the storage mode has been activated.
35e721bf 786
787 if (fDim < i)
788 {
789 cout << " *AliSample::GetMinimum* Error : Dimension less than " << i << endl;
790 return 0;
791 }
792
25eefd00 793 if (!fRemove) return fMin[i-1];
794
35e721bf 795 if (!fStore)
796 {
797 cout << " *AliSample::GetMinimum* Error : Storage of data entries was not activated." << endl;
798 return 0;
799 }
800
801 if (fN<=0) return 0;
802
803 Float_t min=0;
804
805 if (i==1) min=fX->At(0);
806 if (i==2) min=fY->At(0);
807 if (i==3) min=fZ->At(0);
808
809 for (Int_t k=1; k<fN; k++)
810 {
811 if (i==1 && fX->At(k)<min) min=fX->At(k);
812 if (i==2 && fY->At(k)<min) min=fY->At(k);
813 if (i==3 && fZ->At(k)<min) min=fZ->At(k);
814 }
815
816 return min;
817}
818///////////////////////////////////////////////////////////////////////////
819Float_t AliSample::GetMaximum(Int_t i) const
820{
821// Provide the maxmum value of a certain variable.
25eefd00 822// In case entries have been removed from the sample, a correct value can
823// only be obtained if the storage mode has been activated.
35e721bf 824
825 if (fDim < i)
826 {
827 cout << " *AliSample::GetMaximum* Error : Dimension less than " << i << endl;
828 return 0;
829 }
830
25eefd00 831 if (!fRemove) return fMax[i-1];
832
35e721bf 833 if (!fStore)
834 {
835 cout << " *AliSample::GetMaximum* Error : Storage of data entries was not activated." << endl;
836 return 0;
837 }
838
839 if (fN<=0) return 0;
840
841 Float_t max=0;
842
843 if (i==1) max=fX->At(0);
844 if (i==2) max=fY->At(0);
845 if (i==3) max=fZ->At(0);
846
847 for (Int_t k=1; k<fN; k++)
848 {
849 if (i==1 && fX->At(k)>max) max=fX->At(k);
850 if (i==2 && fY->At(k)>max) max=fY->At(k);
851 if (i==3 && fZ->At(k)>max) max=fZ->At(k);
852 }
853
854 return max;
855}
856///////////////////////////////////////////////////////////////////////////
90a99772 857Double_t AliSample::GetMedian(TH1* histo,Int_t mode) const
858{
f535bc3b 859// Provide the median in X or Y from the specified 1D histogram.
90a99772 860// For this functionality it is not needed to activate the storage mode.
861//
f535bc3b 862// In case of X-median, this facility uses TH1::GetQuantiles, which
90a99772 863// provides a median value which in general is different from any of the
f535bc3b 864// central bin X values. The user may force the returned X-median to be
90a99772 865// the corresponding central bin X value via the "mode" input argument.
866//
f535bc3b 867// mode = 0 ==> The pure TH1::GetQuantiles X-median value is returned.
868// 1 ==> The corresponding central bin X value is returned as X-median.
869// 2 ==> The Y-median value is returned.
90a99772 870//
871// By default mode=1 will be used, to agree with the AliSample philosophy.
872
873 if (!histo) return 0;
874
875 Double_t median=0;
876
f535bc3b 877 if (mode==2) // Median of Y values
878 {
879 AliSample temp;
880 temp.SetStoreMode(1);
881 Float_t val=0;
882 for (Int_t i=1; i<=histo->GetNbinsX(); i++)
883 {
884 val=histo->GetBinContent(i);
885 temp.Enter(val);
886 }
887 median=temp.GetMedian(1);
888 }
889 else // Median of X values
890 {
891 Double_t q[1];
892 Double_t p[1]={0.5};
893 histo->ComputeIntegral();
894 Int_t nq=histo->GetQuantiles(1,q,p);
90a99772 895
f535bc3b 896 if (!nq) return 0;
90a99772 897
f535bc3b 898 median=q[0];
899 if (mode==1)
900 {
901 Int_t mbin=histo->FindBin(q[0]);
902 median=histo->GetBinCenter(mbin);
903 }
90a99772 904 }
905
906 return median;
907}
908///////////////////////////////////////////////////////////////////////////
909Double_t AliSample::GetSpread(TH1* histo,Int_t mode) const
910{
f535bc3b 911// Provide the spread w.r.t. the X or Y median for the specified 1D histogram.
912// The spread is defined as the average of |median-val|.
90a99772 913// For this functionality it is not needed to activate the storage mode.
914//
f535bc3b 915// In case of X-spread, this facility uses TH1::GetQuantiles to determine
916// the X-median, which provides a median value which in general is different
917// from any of the central bin X values. The user may force the used X-median
918// to be the corresponding central bin X value via the "mode" input argument.
90a99772 919//
f535bc3b 920// mode = 0 ==> The pure TH1::GetQuantiles X-median value is used
921// 1 ==> The corresponding central bin X value is used as X-median
922// 2 ==> The spread in Y-values w.r.t. the Y-median will be provided
90a99772 923//
924// By default mode=1 will be used, to agree with the AliSample philosophy.
925
926 if (!histo) return 0;
927
928 Double_t spread=0;
929
90a99772 930 Int_t nbins=histo->GetNbinsX();
f535bc3b 931
932 if (mode==2) // Spread in Y values
90a99772 933 {
f535bc3b 934 AliSample temp;
935 temp.SetStoreMode(1);
936 Float_t val=0;
937 for (Int_t i=1; i<=nbins; i++)
90a99772 938 {
f535bc3b 939 val=histo->GetBinContent(i);
940 temp.Enter(val);
90a99772 941 }
f535bc3b 942 spread=temp.GetSpread(1);
943 }
944 else // Spread in X values
945 {
946 Double_t median=GetMedian(histo,mode);
947 Double_t x=0,y=0,ysum=0;
948 for (Int_t jbin=1; jbin<=nbins; jbin++)
949 {
950 x=histo->GetBinCenter(jbin);
951 y=histo->GetBinContent(jbin);
952 if (y>0)
953 {
954 spread+=fabs(x-median)*y;
955 ysum+=y;
956 }
957 }
958 if (ysum>0) spread=spread/ysum;
90a99772 959 }
90a99772 960
961 return spread;
962}
963///////////////////////////////////////////////////////////////////////////