# ROOT version 3.02/06 Release Notes

    The ROOT Team is pleased to announce the release of ROOT version 3.02.

    Compared to the previous production release (v3.01/06) this new version
    backward compatible with the previous production version has major
    enhancements described below:

    Binaries for all supported platforms are available at:

          http://root.cern.ch/root/Version302.html

    Versions for AFS have also been updated. See the list of supported platforms:

          http://root.cern.ch/root/AFS.html

    Both links are reachable via the download page.

    Rene Brun, Philippe Canal, Masaharu Goto, Fons Rademakers

    TStreamerInfo (I/O sub system)
    ==============================

    Added support for type char*.

    Added a new static member function TStreamerInfo::SetCanDelete().
    When this option is activated (default), ReadBuffer() automatically
    delete objects when a data member is a pointer to an object.
    If your constructor is not pre-setting pointers to 0, you must
    call this static function TStreamerInfo::SetCanDelete(kFALSE);

    Added native support for a pointer to a fixed size array of pointers.

    Several changes related to the introduction of the new classes TRef.

    Many improvements to support the case called "fake class" in case
    the shared library containing the classes is not available, or the
    complex case where the shared lib is dynamically linked after opening
    a file containing the classes in the shared lib.

    CINT
    ====

    Latest version of CINT with more bug fixes and more template support.

    The ZIP package
    ===============

    Minor modification by Maarten Ballintijn in the ZIP Inflate package
    resulting in a gain of about 20 per cent in read time.

    New class TUUID
    ===============

    This class defines a UUID (Universally Unique IDentifier), also
    known as GUIDs (Globally Unique IDentifier). A UUID is 128 bits
    long, and if generated according to this algorithm, is either
    guaranteed to be different from all other UUIDs/GUIDs generated
    until 3400 A.D. or extremely likely to be different. UUIDs were
    originally used in the Network Computing System (NCS) and
    later in the Open Software Foundation's (OSF) Distributed Computing
    Environment (DCE).

    New class TMD5
    ==============

    This code implements the MD5 message-digest algorithm.
    To compute the message digest of a chunk of bytes, create an
    TMD5 object, call Update() as needed on buffers full of bytes, and
    then call Final(), which will, optinally, fill a supplied 16-byte
    array with the digest.

    New classes TProcessID
    ======================

    A TProcessID identifies a ROOT job in a unique way in time and space.
    The TProcessID title consists of a TUUID object which provides a globally
    unique identifier (for more see TUUID.h).

    A TProcessID is automatically created by the TROOT constructor.
    When a TFile contains referenced objects (see TRef), the TProcessID
    object is written to the file.
    If a file has been written in multiple sessions (same machine or not),
    a TProcessID is written for each session.
    These objects are used by the class TRef to uniquely identified
    any TObject pointed by a TRef.

    When a referenced object is read from a file (its bit kIsReferenced is set),
    this object is entered into the objects table of the corresponding TProcessID.
    Each TFile has a list of TProcessIDs (see TFile::fProcessIDs) also
    accessible via TProcessID::fgPIDs (for all files).
    When this object is deleted, it is removed from the table via the cleanup
    mechanism invoked by the TObject destructor.

    Each TProcessID has a table (TObjArray *fObjects) that keeps track
    of all referenced objects. If a referenced object has a fUniqueID set,
    a pointer to this unique object may be found via fObjects->At(fUniqueID).
    In the same way, when a TRef::GetObject is called, GetObject uses
    its own fUniqueID to find the pointer to the referenced object.
    See TProcessID::GetObjectWithID and PutObjectWithID.

    New classes TRef, TRefArray
    ===========================

    A TRef is a lightweight object pointing to any TObject.
    This object can be used instead of normal C++ pointers in case
     - the referenced object R and the pointer P are not written to the same file
     - P is read before R
     - R and P are written to different Tree branches

    When a top level object (eg Event *event) is a tree/graph of many objects,
    the normal ROOT Streaming mechanism ensures that only one copy of each object
    in the tree/graph is written to the output buffer to avoid circular
    dependencies.
    However if the object event is split into several files or into several
    branches of one or more Trees, normal C++ pointers cannot be used because
    each I/O operation will write the referenced objects.
    When a TRef is used to point to a TObject *robj.
    For example in a class with
        TRef  fRef;
    one can do:
        fRef = robj;  //to set the pointer
    this TRef and robj can be written with two different I/O calls
    in the same or different files, in the same or different branches of a Tree.
    If the TRef is read and the referenced object has not yet been read,
    the TRef will return a null pointer. As soon as the referenced object
    will be read, the TRef will point to it.

    TRef also supports the complex situation where a TFile is updated
    multiple times on the same machine or a different machine.

    How does it work
    ----------------

    A TRef is itself a TObject with an additional transient pointer fPID.
    When the statement fRef = robj is executed, the following actions happen:
      - The pointer fPID is set to the current TProcessID.
      - The current ObjectNumber (see below) is incremented by one.
      - robj::fUniqueID is set to ObjectNumber.
      - In the fPID object, the element fObjects[ObjectNumber] is set to robj
      - ref::fUniqueID is also set to ObjectNumber.
    After having set fRef, one can immediatly return the value of robj
    using fRef.GetObject(). This function returns directly fObjects[fUniqueID]
    from the fPID object.

    When the TRef is written, the process id number pidf of fPID is written
    in addition to the TObject part of TRef (fBits,fUniqueID).
    When the TRef is read, its pointer fPID is set to the value
    stored in the TObjArray of TFile::fProcessIDs (fProcessIDs[pidf]).

    When a referenced object robj is written, TObject::Streamer writes
    in addition to the standard (fBits,fUniqueID) the pidf.
    When this robj is read by TObject::Streamer, the pidf is read.
    At this point, robj is entered into the table of objects of the TProcessID
    corresponding to pidf.

    WARNING: If MyClass is the class of the referenced object, The TObject
             part of MyClass must be Streamed. One should not
             call MyClass::Class()->IgnoreTObjectStreamer()

    ObjectNumber
    ------------

    When an object is referenced (see TRef assignement operator or TRefArray::Add)
    a unique identifier is computed and stored in both the fUniqueID of the
    referenced and referencing object. This uniqueID is computed by incrementing
    by one the static global in TProcessID::fgNumber. fUniqueID is some sort of
    serial object number in the current session. One can retrieve at any time
    the current value of fgNumber by calling the static function TProcessID::GetObjectCount
    or set this number via TProcessID::SetObjectCount.
    To avoid a growing table of fObjects in TProcessID, in case, for example,
    one processes many events in a loop, it might be necessary to reset the
    ObjectNumber at the end of processing of one event. See an example
    in $ROOTSYS/test/Event.cxx (look at function Build).
    The value of ObjectNumber (say saveNumber=TProcessID::GetObjectCount()) may be
    saved at the beginning of one event and reset to this original value
    at the end of the event via TProcessID::SetObjectCount(saveNumber). These
    actions may be stacked.

    Action on Demand
    ----------------

    The normal behaviour of a TRef has been described above. In addition,
    TRef supports also "Actions on Demand". It may happen that the object
    referenced is not yet in memory, on a separate file or not yet computed.
    In this case TRef is able to automatically execute an action:
      - call to a compiled function (static function of member function)
      - call to an interpreted function
      - execution of a CINT script

    How to select this option?
    In the definition of the TRef data member in the original class, do:
      TRef  fRef;   //EXEC:execName. points to something
    When the special keyword "EXEC:" is found in the comment field of the member,
    the next string is assumed to be the name of a TExec object.
    When a file is connected, the dictionary of the classes on the file
    is read in memory (see TFile::ReadStreamerInfo). When the TStreamerElement
    object is read, a TExec object is automatically created with the name
    specified after the keywork "EXEC:" in case a TExec with a same name does
    not already exist.
    The action to be executed via this TExec can be specified with:
       - a call to the TExec constructor, if the constructor is called before
         opening the file.
       - a call to TExec::SetAction at any time.
         One can compute a pointer to an existing TExec with a name with:
           TExec *myExec = gROOT->GetExec(execName);
         myExec->SetAction(actionCommand); where
         - actionCommand is a string containing a CINT instruction. Examples:
             myExec->SetAction("LoadHits()");
             myExec->SetAction(".x script.C");

    When a TRef is dereferenced via TRef::GetObject, its TExec will be
    automatically executed. In the function/script being executed, one or more
    of the following actions can be executed:
     - load a file containing the referenced object. This function typically
       looks in the file catalog (GRID).
     - compute a pointer to the referenced object and communicate this pointer
       back to the calling function TRef::GetObject via:
         TRef::SetObject(object).
    As soon as an object is returned to GetObject, the fUniqueID of the TRef is set
    to the fUniqueID of the referenced object. At the next call to GetObject,
    the pointer stored in fPid:fObjects[fUniqueID] will be returned directly.

    An example of action on demand is shown in $ROOTSYS/test/Event.h with
    the member:
         TRef    fWebHistogram;   //EXEC:GetWebHistogram
    When calling fWebHistogram.GetObject(), the function GetObject
    will automatically invoke a script GetWebHistogram.C via the interpreter.
    An example of a GetWebHistogram.C script is shown below
       void GetWebHistogram() {
          TFile *f= TFile::Open("http://root.cern.ch/files/pippa.root");
          f->cd("DM/CJ");
          TH1 *h6 = (TH1*)gDirectory->Get("h6");
          h6->SetDirectory(0);
          delete f;
          TRef::SetObject(h6);
       }

    In the above example, a call to fWebHistogram.GetObject() executes the
    script with the function GetWebHistogram. This script connects a file
    with histograms: pippa.root on the ROOT Web site and returns the object h6
    to TRef::GetObject.
    Note that if the definition of the TRef fWebHistogram had been:
         TRef    fWebHistogram;   //EXEC:GetWebHistogram()
    then, the compiled or interpreted function GetWebHistogram() would have
    been called instead of the CINT script GetWebHistogram.C

    Array of TRef
    -------------

    The special class TRefArray should be used to store multiple references.
    A TRefArray has one single pointer fPID for all objects in the array.
    It has a dynamic compact table of fUniqueIDs. Use a TRefArray rather
    then a collection of TRefs.

    Example:
    Suppose a TObjArray *mytracks containing a list of Track objects
    Suppose a TRefArray *pions containing pointers to the pion tracks in mytracks.
      This list is created with statements like: pions->Add(track);
    Suppose a TRefArray *muons containing pointers to the muon tracks in mytracks.
    The 3 arrays mytracks,pions and muons may be written separately.

    $ROOTSYS/test/Event
    ===================

    Test program modified to illustrate the use of TRef and TRefArray

    TTree: Creation of branches
    ===========================

    Creation of branches on separate files:
    when branch file names are not absolute and not an URL and the tree file
    name is absolute or an URL then make the branch files relative to the path
    of the tree file. In this case one can move the tree + all branch files to
    a different location in the file system and still access the branch files.

    Added a new branch constructor:
       Int_t TTree::Branch(TCollection *list, Int_t bufsize, Int_t splitlevel,
                           const char *name)
    This function creates one branch for each element in the collection.
    Each entry in the collection becomes a top level branch if the
    corresponding class is not a collection. If it is a collection, the entry
    in the collection becomes in turn top level branches, etc.
    The splitlevel is decreased by 1 everytime a new collection is found.
    For example if list is a TObjArray*
      - if splitlevel = 1, one top level branch is created for each element
        of the TObjArray.
      - if splitlevel = 2, one top level branch is created for each array element.
        if, in turn, one of the array elements is a TCollection, one top level
        branch will be created for each element of this collection.

    In case a collection element is a TClonesArray, the special Tree constructor
    for TClonesArray is called.
    The collection itself cannot be a TClonesArray.

    The function returns the total number of branches created.

    If name is given, all branch names will be prefixed with name_.

    IMPORTANT NOTE1: This function should not be called with splitlevel < 1.

    IMPORTANT NOTE2: The branches created by this function will have names
    corresponding to the collection or object names. It is important
    to give names to collections to avoid misleading branch names or
    identical branch names. By default collections have a name equal to
    the corresponding class name, eg the default name for a TList is "TList".

    TTree::GetEntry(): added the following important comments
    =========================================================

    By default, GetEntry() reuses the space allocated by the previous object
    for each branch. You can force the previous object to be automatically
    deleted if you call mybranch.SetAutoDelete(kTRUE) (default is kFALSE).
    Example:
    Consider the example in $ROOTSYS/test/Event.h
    The top level branch in the tree T is declared with:
       Event *event = 0;  //event must be null or point to a valid object
                          //it must be initialized
       T.SetBranchAddress("event",&event);
    When reading the Tree, one can choose one of these 3 options:

    OPTION 1
    --------

       for (Int_t i=0;i<nentries;i++) {
          T.GetEntry(i);
          the objrect event has been filled at this point
       }
    The default (recommended). At the first entry an object of the
    class Event will be created and pointed by event.
    At the following entries, event will be overwritten by the new data.
    All internal members that are TObject* are automatically deleted.
    It is important that these members be in a valid state when GetEntry
    is called. Pointers must be correctly initialized.
    However these internal members will not be deleted if the characters "->"
    are specified as the first characters in the comment field of the data
    member declaration.
    If "->" is specified, the pointer member is read via pointer->Streamer(buf).
    In this case, it is assumed that the pointer is never null (case
    of pointer TClonesArray *fTracks in the Event example).
    If "->" is not specified, the pointer member is read via buf >> pointer.
    In this case the pointer may be null. Note that the option with "->"
    is faster to read or write and it also consumes less space in the file.

    OPTION 2
    --------

    The option AutoDelete is set:
      TBranch *branch = T.GetBranch("event");
      branch->SetAddress(&event);
      branch->SetAutoDelete(kTRUE);
       for (Int_t i=0;i<nentries;i++) {
          T.GetEntry(i);
          the objrect event has been filled at this point
       }
    In this case, at each iteration, the object event is deleted by GetEntry
    and a new instance of Event is created and filled.

    OPTION 3
    --------

    Same as option 1, but you delete yourself the event:
       for (Int_t i=0;i<nentries;i++) {
          delete event;
          event = 0;  EXTREMELY IMPORTANT
          T.GetEntry(i);
          the objrect event has been filled at this point
       }

    It is strongly recommended to use the default option 1. It has the
    additional advantage that functions like TTree::Draw (internally
    calling TTree::GetEntry) will be functional even when the classes in the
    file are not available.

    TTree::MakeClass()
    ==================

    Added support for the new branch style TBranchElement.
    Several improvements in the code generator in case of C++ complex constructs.

    TTree::Print()
    ==============

    Added a new option "toponly" in TTree::Print() to print the space used
    by the top branches only. A top branch is a branch that does not have
    a "." in its name. The space reported includes the total of all
    sub-branches of a top branch.

    TBranch::SetFile()
    ==================

    Modify the TBranch::SetFile functions such that the daughter branches are
    also diverted to the specified file.

    TTreeFormula
    ============

    Several enhancements:
      - added support for TCutG which TChains
      - added several additional protections
      - fixed memory leaks.
      - added support for leaves with same name in different branches
      - one can call a method of a class in a TClonesArray
      - added support for casting implemented as a 'dynamic_cast' so that
           TTree::Draw("((TTUBE*)fShape)->GetRmin()")
        will histogram ONLY the entries containing a TTUBE (or an object
        inheriting from TTUBE).
      - functions that return an int are now histogramed in integer format
      - rationalize treatment of char arrays which are now treated as a string
        if and only if the context requires it.

    TEventList upgrade (related to TTreeFormula)
    ============================================

    TEventList object now includes ALL the entry/event that has any subparts
    that match the criteria, i.e.  With fTracks a TClonesArray, the following call
       T->Draw(">>elist","fTracks.fPx>0");
    will create a TEventList elist that contains ALL the entries that have one
    or more tracks which have fPx greater than zero. Prior to this updates
    elist would contain ONLY the entries where fTracks.A(0).fPx is greater
    than zero. Another example:
       T->Draw(">>pxlist","fPx>2.7");
    creates a TEventList 'pxlist' that list all events that have one or more
    tracks with fPx greater than 2.7:
       T->SetEventList(pxlist);
       T->Draw("fPx");
    will draw the fPx of ALL the tracks of the events that have at least
    one track with a fPx greater than 2.7:
       pxlist->SetReapplyCut(kTRUE);
       T->SetEventList(pxlist);
       T->Draw("fPx");
    will draw the fPx of ONLY the tracks that have a fPx greater than 2.7.

    TTreeRow
    ========

    Class has been rewritten (6 times faster and consumes less memory).
    This class is used by TTree::Query().

    TChain
    ======

    Improvements in TChain::Merge(). When merging many files, it may happen
    that the resulting file reaches a size > fgMaxMergeSize (default = 1.9 GBytes).
    In this case the current file is automatically closed and a new file started.
    If the name of the merged file was "merged.root", the subsequent files
    will be named "merged_1.root", "merged_2.root", etc.
    fgMaxMergeSize may be modified via the static function SetMaxMergeSize.
    The function Merge returns the total number of files generated.

    TChain::Merge() creates a new Tree containing ONLY the active branches.

    TChain::Add() supports wildcarding (Andre Holzner).

    In TChain::Addfile() remove the limitation that the file name must contain
    the string ".root". ".root" is necessary only in case one wants to specify
    a Tree in a subdirectory of a ROOT file with eg, the format:
       //machine/file_name.root/subdir/tree_name

    TH1
    ===

    Add new function TH1::GetQuantiles():
       Int_t TH1::GetQuantiles(Int_t nprobSum, Double_t *q,
                               const Double_t *probSum)
    computes Quantiles for this histogram.
    Quantile x_q of a probability distribution Function F is defined as
       F(x_q) = q with 0 <= q <= 1.
    For instance the median x_0.5 of a distribution is defined as that value
    of the random variable for which the distribution function equals 0.5:
       F(x_0.5) = Probability(x < x_0.5) = 0.5
    (function implemented in collaboration with Eddy Offermann, Renaissance)

    TH1::Rebin() function now in the TH1 context menu.

    Fixed a bug in TH1::Fit() when adding a copy of teh function to the list
    of functions.
    Add new comments and examples in TH1::Fit() to illustrate how to set limits
    for a parameter or how to fix a parameter.

    Note that during the fitting process, the user may call the new static
    function TF1::RejectPoint() (see TF1).

    In TH1::Draw() and TGraph::Draw() a new canvas is automatically created
    in case gPad points to a non-editable pad/canvas.

    TH2
    ===

    Modify the default arguments in TH2::ProfileX,Y, ProjectionX,Y.
    With the new convention, the projection does not include the under/overflow
    bins. When all bins are included, the number of entries in the projection
    is set to the number of entries of the 2-D histogram, otherwise
    the number of entries is incremented by 1 for all non empty cells.

    TH3
    ===

    Implement support for variable bin size histograms in TH3::Project3D().
    Thanks to Albert Lehmann

    New class THStack
    =================

    This new class may be used to draw a stack of histograms (1-d and 2-d)
    See example in new tutorial hstack.C.

    TProfile
    ========

    TProfile::ProjectionX() supports profiles with variable bin size.

    THistPainter
    ============

    PaintErrors: use histogram attributes in case of options "e3", "e4".
    Optimize size and end position of error bars around the symbol
    in case of assymetric pads in THistPainter::PaintErrors.
    Implement a patch from Jiri Masik to avoid drawing the horizontal lines
    twice for the error bars in case the options "hist" and "e" are specified.

    The THistPainter and TLego classes have been extended with new functions
    to draw selected regions of a 2-d histogram.
    One can create one or more graphical cuts (TCutG objects) and specify
    this (these) cuts in option string of the Draw function. Example, assuming
    two graphical cuts with name "cut1" and "cut2", one can do:
       h1.Draw("lego");
       h2.Draw("[cut1,-cut2],surf,same");
    The second Draw will superimpose on top of the first lego plot a subset of
    h2 using the "surf" option with:
      -all the bins inside cut1
      -all the bins outside cut2
    Up to 16 cuts may be specified in the cut string delimited by "[..]"

    Currently only the following drawing options are sensitive to the cuts
    option: col, box, scat, hist, lego, surf and cartesian coordinates only.

    Optimize the axis layout in THistPainter::PaintLegoAxis when painting
    a surface at theta=90 and phi = 0 degrees (case of option cont4).

    TAxis
    =====

    Added new function TAxis::SetRangeUser(Axis_t ufirst, Axis_t ulast).
    This function is a shortcut calling:
       TAxis::SetRange(Int_t binfirst, Int_t binlast).
    The new function is visible in the context menu.

    Add support for zooming on the Z axis in case of a 3-D view or zooming
    on the palette axis in case of a 2-d view.

    Delete the unused member fXlabels and associated member functions:
    GetBinLabel, GetLabels, SetBinLabel and SetLabels.

    TGaxis
    ======

    Added a new member function TGaxis::SetNoExponent() to disable the notation
    with 10^N when drawing the axis. This option is automatically selected
    when drawing TAxis objects having this property.
    Note that this option is implicitly selected if the number of digits
    to draw a label is less than the fgMaxDigits global member.
    SetNoexponent is also available from the TAxis context menu.

    A few optimisations in TGaxis::PainTAxis in case a transformation function
    has been specified in the constructor.
    Update the example in this constructor to show a case with a log function.

    TPad/TVirtualPad
    ================

    added support for fixed aspect ratio. New methods SetFixedAspectRatio() and
    HasFixedAspectRatio(). After fixing the aspect ratio the pad mouse
    resize functions will maintain the current aspect ratio. SetFixedAspectRatio()
    is available as toggle via the context menu.

    Added signals RangeChanged() and RangeAxisChanged(). For description
    of usage see Range() and RangeAxis(). Basically it allows for easy
    monitoring of zoom events.

    class TGraph
    ============

    Added the following new functions:
        Double_t GetCorrelationFactor() const;
        Double_t GetCovariance() const;
        Double_t GetMean(Int_t axis=1) const;
        Double_t GetRMS(Int_t axis=1) const;

    In all the TGraphX classes add a new method Apply suggested and implemented
    by Miroslav Helbich <helbich@mail.desy.de>
    If one has points x,y of TGraph, sometimes it is convenient to apply a
    function to those points e.g y=f(x,y). There are some examples like scale
    the points by some number f(x,y)=y*scale factor or if you try to fit some
    complicated formula it is sometimes better to do the transformation first.

    Implement new option "[]" in the TGraph::Paint() and TGraphAsymmErrors::Paint().
    if option "[]" is specified only the end vertical/horizonthal lines
    of the error bars are drawn. This option is interesting to superimpose
    systematic errors on top of a graph with statistical errors.

    Modify the Paint functions to paint the TGraph symbols after the error bars.

    New class TGraphSmooth (Christian Stratowa)
    ===========================================

    This class is a helper class to smooth TGraph, TGraphErrors or interpolate
    a graph at a set of given points. See new tutorial motorcycle.C

    TLegend
    =======

    Several cosmetic improvements.
    Modify algorithm in TLegend::PaintPrimitives() when painting the fill area.
    Use TPad::PaintFillArea() instead of a box. Painting via a TBox had side
    effects when painting with fill styles with hatches.

    TLatex
    ======

    New symbol #tilde supported.
    To be consistent with LateX, #varepsilon replaces the old #epsilon.
    The new #epsilon is a new character in the Tlatex table.
    varepsilon and epsilon look now identical to the LateX output.

    TF1, TF2
    ========

    When a TF1/TF2 was created with an interpreted or compiled function,
    it was not possible to save the object in a file and read it in a separate
    program because TF1/TF2 did not save the code of the interpreted function.
    Only functions created with inline expressions could be paint in a separate
    session. In TF1, we already had the logic to save an array fSave with
    the function values created at fNpx points. TF2 has been modified
    to provide the same functionality. One can save a TF2 and draw it
    again in a new session.
    To implement this feature, the signature of the function TF1::Save
    has been modified to be general for 1,2 and 3-d functions.
    The classes TH1 and TGraph where TF1::Save was called have been
    modified accordingly.

    Interpreted or compiled functions are saved at fNpx points.
    Basic functions saved with the original definition.

    TH1 and TGraph objects including fit functions are now fully saved
    and rebuilt.

    Add new function TF1::GetQuantiles() (see TH1::GetQuantiles).

    Add new static global member fgRejectPoint with the new static functions:
       void TF1::RejectPoint(Bool_t reject=kTRUE)
       Bool_t TF1::RejectedPoint()

    The function TF1::RejectPoint() may be used in a user fitting function
    to reject points. The fgRejectPoint is automatically reset.

    A new member function TF1::IsInside() has been added.
    Currently it returns kTRUE if the point is inside the function limits.
    This function is redefined in TF2 and TF3.
    The main purpose of this function is to give additional possibilities
    in functions deriving from TF1. For example, if a function is only
    defined in some specific non-contiguous ranges, this could be
    implemented in a class deriving from TF1 and simply redefining
    the function TF1::IsInside.

    In TF1::DistancetoPrimitive(), evaluate the function only if the point is
    inside the function range.

    TColor
    ======

    Added three new static methods:
      TColor::GetColor(Int_t r, Int_t g, Int_t b) with r,g,b in range [0,255]
      TColor::GetColor(Float_t r, Float_t g, Float_t b) with r,g,b in range [0,1]
      TColor::GetColor(const char *hexcolor) with hexcolor of form "#rrggbb"
    these methods try to find the color with the specified rgb value in the
    list of existing colors, if the color does not exist it will create a
    new TColor with the name "#rrggbb", add it to the global list of colors
    and return the color number.

    Also made the methods HLStoRGB() and RGBtoHLS() static.

    TPostScript
    ===========

    Add new functions in the Postscript interface to support drawing of images
    with Postscript (thanks to Olivier Couet).

    Some special characters like TLatex #varphi were not correctly
    interpreted by TPostScript.

    TStyle
    ======

    Add more comments to the TStyle constructor.

    Add new function TStyle::SetTitlePS(const char *title) to specify
    a Title in the Postscript file.

    Two fixes by Jiri Masik in the TStyle ctor to avoid modifying the current
    style.

    TBits
    =====

    Improve speed of TBits::CountBits() (factor 8).
    New functions: FirstNullBit() and FirstSetBit().

    TMatrix, TMatrixD
    =================

    Interesting additions to TMatrix and TMatrixD by Eddy Offermann.
    When working with the TMatrix class I was confronted again with a bit
    of a limitation:

    1) The current algorithm is not capable of inverting a diagional matrix
    whose determinant is < 1e-300 giving a floating exception, not to speak
    of more complex non-diagonal cases.

    The solution is simple: first divid the element (i,j) through val, where
    val = sqrt(element(i,i)*element(j,j)) and doing this again after inversion.

    2) In case of a symmetric pos def matrix, a simpler/faster algorithm
    can be used. I have added the kInvertedPosDef type to both classes.

    TLorentzVector
    ==============

    Add a comment about the Plus() and Minus() functions
    Member functions Plus() and Minus() return the positive and negative
    light-cone components:

      Double_t pcone = v.Plus();
      Double_t mcone = v.Minus();

    CAVEAT: The values returned are T{+,-}Z. It is known that some authors
    find it easier to define these components as (T{+,-}Z)/sqrt(2). Thus
    check what definition is used in the physics you're working in and adapt
    your code accordingly.

    TThread
    =======

    Many improvements in this class: many thanks to
     - the GSI G04 group
     - Mathieu de Naurois
    For more details, see the CVS history notes.

    TMemberInspector
    ================
    A BACKWARD INCOMPATIBLE change in the function Inspect.
    The new signature is:
      void Inspect(TClass *cl, const char *parent, const char *name, const void *addr);

    THtml
    =====

    Many improvements by Axel Naumann. Quoted from a mail from Axel:
    "NOTE: I have changed the standard in one case. Please tell me if you want to
    reversed. Due to this change all MyClass.html files will contain the "last
    changed" date, even if not given in the file (if lastChanged=="", THtml
    takes the current date, which in most cases should be a good approximation -
    if the file weren't changed one wouldn't regenerate the documentation). See
    the attached html file for an example.

    To include your own files, e.g. a header, edit e.g.
    $ROOTSYS/etc/system.rootrc. Add lines with:
    "Root.Html.Header:    <yourfilename>"
    Make sure the file ends with a new line (this is valid for all
    files THtml is processing, shall we change that?)!

    You can also say "Root.Html.Header:    <your filename>+" in which case THtml
    will first write its standard header and then the one provided by you (for
    the footer it's the other way around, first yours, then the standard)."

    Bugfixes:
    - sometimes THtml wasn't able to identify a method of namespace'd classes in
      source files
    - namespaced classes as return types are now correctly identified
    - global enums are known as classes to CINT although they don't have the
      ClassDef macro. If such an enum showed up in a source file it resulted in a
      link to their - non-existent - documentation page (as CINT returned a class
      info), but as they don't have DeclFile / ImplFile no documentation is
      generated for them. I resolved that by only generating a link for globals
      only if the class info has a decl file specified. Thus gROOT still points to
      TROOT.html, but kChildFrame doesn't point to EFrameType. Bug found by Thomas
      Bretz.
    - fXWho was set in the code. Now the env var Root.Html.XWho is read in; if
      it's not set, the old value is used.
    - unused var "funcName" in ClassDescription removed (there was one with
      local scope & another one with method scope of the same name, one of them
      was unused)
    - gROOT is not asked anymore if "const" is a global object each time a
      "const" shows up in the source file. Takes too much time.

    Improvements:
    - documentation (of the class responsible for self-documenting...).
    - Authors: multiple authors can be given (comma separated list), custom HTML
      link can be specified after each author name in <...>.
    - some char strings were far too short and resulted in out-of-bounds memory
      writes. Author, copyright, update and "nextLine" are changed (some from 80)
      to 1024 chars now.
    - Not documented: Doc++ compatible comments outside of methods. To enable it
      the env var "Root.Html.DescriptionStyle" has to be set to "Doc++". THtml's
      new ability does not influence anything else, it's completely independent.
      Thomas Bretz and I have tested this for a while. But I'm not sure if
      allowing multiple documentation styles is a good thing. So we could just
      keep that a secret...

    TPrincipal
    ==========

    Several improvements by Christian Holm Christiansen.

    TObjectTable
    ============

    Add new option in TObjectTable::Print(), if option ="all" prints the
    list of all objects with the format object number, pointer, class name,
    object name.

    New or modified tutorials
    =========================

    quantiles.C  New tutorial to illustrate teh use of TH1::GetQuantiles().
    hstack.C     New tutorial to illustrate the use of the new class THStack.
    motorcycle.C New tutorial to illustratre the new class TGraphSmooth.
    Worldmap.C   New GUI demo by Valeriy Onuchin.
    PhaseSpace.C New tutorial illustrating the use of the class TGenPhaseSpace by
                 Valerio Filippini.
    graphApply.C New tutorial  to demonstrate the functionality of TGraphX::Apply()
                 method by Miro Helbich.
    waves.C      New tutorial illustrating the use of color palettes (Otto Schaile)
    greyscale.C  New tutorial showing the use of TColor::GetColor() and how to set
                 a pad to the exact same color as the GUI.
    DynamicSlice.C  Improved quality of graphics
    FittingDemo.C   idem
    first.C         idem
    second.C        idem

    TDatime
    =======

    Add boolean argument "toGMT" to Convert(). The default is false for backward
    compatibility, setting it to true returns the unix time in GMT.

    TMath
    =====

    Make the array arguments const in functions LocMin(), LocMax(), BinarySearch()
    and Sort(). Add new signatures with Long_t.
    New functions TMath::IsNan() and TMath::Finite().

    TString
    =======

    Add operator+=(Float_t) and operator+=(Double_t). Both use %9.9g to
    encode floating point number. If other encoding is desired do e.g.:
    TString(Form("%6.2f", myfloat))

    TBuffer
    =======

    New argument "adopt" to TBuffer ctor and to SetBuffer(). The default
    value of the argument is kTRUE. When this value is kFALSE the buffer
    passed will not be adopted by TBuffer and not deleted in the dtor
    or in SetBuffer() when a new buffer is passed in.
    *** Attention: The default value of adopt is backward incompatible for
        the SetBuffer() call. This new default behavior was introduced in v3.02/04.

    TSystem
    =======

    Add two new getters returning the architecture and the complete built
    node spec:
       TSystem::GetBuildArch()
       TSystem::GetBuildNode()

    TStorage
    ========

    New methods ReAllocChar() and ReAllocInt() to be used to reallocate
    arrays of chars or ints. These methods will use new char[] and new int[]
    to realloc the original arrays. Using ReAlloc() will give complaints from
    memory checkers like Purify and could be a potential problem in case
    for example ::operator new[]() uses a different pool then ::operator new().

    Port of ROOT GUI to Win32
    =========================

    Bertrand Bellenot contributed to the big effort of porting the ROOT GUI
    to Win32 using the Win32 version of GDK. This port is a work in progress
    but already quite functional. Still missing, multiplexing between console
    and graphics input. To use it do in tutorials, e.g.:
       root demos.C
       root benchmarks.C
       root guitest.C
    Or in test build guitest and guiviewer which don't use the console.
    To build this special Win32 version of ROOT do:
       ./configure win32gdk
       make

    TGMenu
    ======

    New methods to allow menu's to be changed after initial creation.
    In TGPopupMenu:
       void            HideEntry(Int_t id);
       Bool_t          IsEntryHidden(Int_t id);
       void            DeleteEntry(Int_t id);
       void            DeleteEntry(TGMenuEntry *entry);
       TGMenuEntry    *GetEntry(Int_t id);
       TGMenuEntry    *GetEntry(const char *s);
       const TList    *GetListOfEntries() const;
    in addition the AddXXXX() methods now accept a before item which allows the
    addition of new menu items before the specified item.

    In TGMenuBar:
       TGPopupMenu *GetPopup(const char *s);
       TGPopupMenu *RemovePopup(const char *s);
    in addition the AddPopup() methods now accept a before item which allows the
    addition of a new menu before the specified menu.

    See the guitest programs on how these new methods should be used.

    TGListBox
    =========

    Added method GetNumberOfEntries().

    TGListView
    ==========

    Add new signals for Clicked() and DoubleClicked() that also report
    the x and y position of the mouse at time of click.

    TGlient
    =======

    New method ProcessEventsFor(TGWindow *w). Use this method to instead
    of TSystem::ProcessEvents() in case you want to allow only events for
    the specified TGWindow to be processed (like when this is a progress
    meter dialog).

    TGNumberEntry
    =============

    Important new widget by Daniel Sigg that allows controlled numeric input
    in many different formats (int, float, hex, time, date, etc.). An example
    of usage is added to guitest.cxx and guitest.C.

    TGTextEntry
    ===========

    Support system wide clipboard (like TGTextEdit). When doing ctl-x (cut)
    or ctrl-v (copy) text is put in global clipboard and can be pasted in any
    other window. Mods by Daniel Sigg <sigg_d@ligo.caltech.edu>.

    Add new signal "TabPressed()" (and event TE_TAB). Using this signal one
    can easily implement focus changing by connecting the signal to a method
    that changes the focus to the next TGTextEntry.

    TQObject & Signal/Slot
    ======================

    Very much improved detection of undefined signal and slot methods.

    h2root
    ======

    h2root modified to support remote files (rfio, castor,etc)

    ACLIC
    =====

    Use by default the "+" option in the autoLinkDef.h file to automatically
    support the new ROOT I/O format.

    Memory Checker
    ==============

    New memory checking system developed by D.Bertini and M.Ivanov.
    To activate the memory checker you have to set in the .rootrc file
    the resource Root.MemCheck to 1 (e.g.: Root.MemCheck: 1) and you
    have to link with libNew.so (e.g. use root-config --new --libs) or
    use rootn.exe. When all this is the case you will find at the end
    of the program execution a file "memcheck.out" in the directory
    where you started your ROOT program. Alternatively you can set
    the resource Root.MemCheckFile to the name of a file to which
    the leak information will be written. The contents of this
    "memcheck.out" file can be analyzed and transformed into printable
    text via the memprobe program (in $ROOTSYS/bin).

    Template support
    ================

    Provide ClassDef and ClassImp macros for classes with two and three
    template arguments. The new macros are: ClassDef2T2, ClassDef3T2 and
    ClassImp2T, ClassImp3T. ClassDefT is independent of the number of template
    arguments. They are used as follows:

       // in header file MyClass.h
       template <typename T> class MyClass1 {
       private:
          T  fA;
          ...
       public:
          ...
          ClassDefT(MyClass1,1)
       };
       ClassDefT2(MyClass1,T)

       template <typename T1, typename T2> class MyClass2 {
       private:
          T1  fA;
          T2  fB;
          ...
       public:
          ...
          ClassDefT(MyClass2,1)
       };
       ClassDef2T2(MyClass2,T1,T2)

       template <typename T1, typename T2, typename T3> class MyClass3 {
       private:
          T1  fA;
          T2  fB;
          T3  fC;
          ...
       public:
          ...
          ClassDefT(MyClass3,1)
       };
       ClassDef3T2(MyClass3,T1,T2,T3)
       ClassImp3T(MyClass3,T1,T2,T3)

       // With in the LinkDef.h file all explicit template instances
       // that will be needed at link time
       #ifdef __CINT__

       #pragma link off all globals;
       #pragma link off all classes;
       #pragma link off all functions;

       #pragma link C++ class MyClass1<float>+;
       #pragma link C++ class MyClass1<double>+;
       #pragma link C++ class MyClass2<float,int>+;
       #pragma link C++ class MyClass2<float,double>+;
       #pragma link C++ class MyClass3<float,int,TObject*>+;
       #pragma link C++ class MyClass3<float,TEvent*,TObject*>+;

       #endif

    SQL interface to SAP DB (http://www.sapdb.org/)
    ===============================================

    SAP DB is an open source (GPL) RDBMS that provides full DB functionality
    and can be easily used instead of Oracle. These classes are based on the
    ODBC call interface and are provided by Mark Hemberger
    (Marc.Hemberger@realtech.de).

    SAP DB is an open, SQL-based, relational database system that provides
    high availability and performance scaling from small to very large
    implementations. In addition, SAP DB goes beyond relational database
    technology by offering object orientation as well as support for managing
    unstructured data. It supports open standards including SQL, JDBC and ODBC;
    access from Perl and Python; and HTTP-based services with HTML or XML content.
    SAP DB (formerly known as ADABAS) has gone Open Source. SAP DB Version
    7.3.00 is available for Linux, Windows NT/Windows 2000, Solaris, HP-UX,
    Tru64, AIX. For those who don't want to pay for an Oracle-like database
    with comparable functionality (and better than MySQL  [;-)]

    SQL interface to PostgreSQL
    ===========================

    PostgreSQL interface provided by Gian Paolo Ciceri.

    ./configure script
    ==================

    Updated ./configure script with better auxiliary package detection.

    Makefiles
    =========

    New Makefiles and improvements in all makefiles.
    New port to Sun SPARC Linux.
    New MacOS X port by Keisuke Fujii
    Support for gcc v3.