Skip to content
Snippets Groups Projects
  1. Apr 25, 2008
  2. Apr 24, 2008
  3. Apr 23, 2008
  4. Apr 16, 2008
  5. Apr 09, 2008
  6. Apr 03, 2008
  7. Apr 01, 2008
  8. Mar 31, 2008
  9. Mar 28, 2008
  10. Mar 27, 2008
  11. Mar 19, 2008
  12. Mar 07, 2008
  13. Mar 03, 2008
    • Fons Rademakers's avatar
      From Andrew Savchenko: · f304eff5
      Fons Rademakers authored
      ROOT can not be compiled with gcc-4.3.
      Some ROOT source files doesn't contain required #include directives,
      for example, they use strlen(), but #include <string.h> is missed or
      malloc() is used and #include <stdlib.h> is missed. 
      
      Earlier versions of gcc allowed some headers to be included implicitly,
      but issued a warning (-Wimplicit-function-declaration). Newer one,
      gcc-4.3 denies such silly behaviour: all required headers must be explicitly
      included. 
      
      Attached patch fixes this. Also it fixes another issue, which disallows
      ROOT to compile under gcc-4.3: C functions don't belong to namespace std,
      so expressions like std::memcpy() are no longer valid and plain memcpy()
      should be used instead.
      
      
      git-svn-id: http://root.cern.ch/svn/root/trunk@22419 27541ba8-7e3a-0410-8455-c3a389f83636
      f304eff5
  14. Feb 15, 2008
  15. Jan 22, 2008
    • Fons Rademakers's avatar
      From Axel: · a5b624b2
      Fons Rademakers authored
      this patch prevents all dictionaries from being rebuild when non dict related
      changes are made in CINT. When the dictionaries change the new
      cint/inc/cintdictversion.h must be updated which triggers a dictionary
      rebuild. For example:
      touch cint/src/v6_var.cxx && make: rebuild no dictionaries
      touch cint/inc/cintdictversion.h && make: rebuild all dictionaries
      touch utils/src/rootcint.cxx && make: rebuild all dictionaries
      
      
      git-svn-id: http://root.cern.ch/svn/root/trunk@21802 27541ba8-7e3a-0410-8455-c3a389f83636
      a5b624b2
  16. Dec 11, 2007
  17. Dec 04, 2007
  18. Nov 26, 2007
  19. Nov 24, 2007
    • Rene Brun's avatar
      Improve TMath::KolmogorovTest (Jason Detwiler) · df1c0743
      Rene Brun authored
      //
      //  Method Improvement by Jason A Detwiler (JADetwiler@lbl.gov)
      //  -----------------------------------------------------------
      //   The nuts-and-bolts of the TMath::KolmogorovTest() algorithm is a for-loop
      //   over the two sorted arrays a and b representing empirical distribution
      //   functions. The for-loop handles 3 cases: when the next points to be 
      //   evaluated satisfy a>b, a<b, or a=b:
      //    
      //      for (Int_t i=0;i<na+nb;i++) {
      //         if (a[ia-1] < b[ib-1]) {
      //            rdiff -= sa;
      //            ia++;
      //            if (ia > na) {ok = kTRUE; break;}
      //         } else if (a[ia-1] > b[ib-1]) {
      //            rdiff += sb;
      //            ib++;
      //            if (ib > nb) {ok = kTRUE; break;}
      //         } else {
      //            rdiff += sb - sa;
      //            ia++;
      //            ib++;
      //            if (ia > na) {ok = kTRUE; break;}
      //            if (ib > nb) {ok = kTRUE; break;}
      //        }
      //         rdmax = TMath::Max(rdmax,TMath::Abs(rdiff));
      //      }
      //    
      //   For the last case, a=b, the algorithm advances each array by one index in an
      //   attempt to move through the equality. However, this is incorrect when one or
      //   the other of a or b (or both) have a repeated value, call it x. For the KS
      //   statistic to be computed properly, rdiff needs to be calculated after all of
      //   the a and b at x have been tallied (this is due to the definition of the
      //   empirical distribution function; another way to convince yourself that the
      //   old CERNLIB method is wrong is that it implies that the function defined as the
      //   difference between a and b is multi-valued at x -- besides being ugly, this
      //   would invalidate Kolmogorov's theorem).
      //    
      //   The solution is to just add while-loops into the equality-case handling to
      //   perform the tally:
      //    
      //         } else {
      //            double x = a[ia-1];
      //            while(a[ia-1] == x && ia <= na) {
      //              rdiff -= sa;
      //              ia++;
      //            }
      //            while(b[ib-1] == x && ib <= nb) {
      //              rdiff += sb;
      //              ib++;
      //            }
      //            if (ia > na) {ok = kTRUE; break;}
      //            if (ib > nb) {ok = kTRUE; break;}
      //         }
      
      
      git-svn-id: http://root.cern.ch/svn/root/trunk@21031 27541ba8-7e3a-0410-8455-c3a389f83636
      df1c0743
Loading