ROOT: headers diff between 5.34.14 and 5.34.17 versions

	Byteswap.h	Byteswap.h

	skipping to change at line 50	skipping to change at line 50
	/* Get the machine specific, optimized definitions. */	/* Get the machine specific, optimized definitions. */
	/* The following is copied from <bits/byteswap.h> (only from RH6.0 and abov e) */	/* The following is copied from <bits/byteswap.h> (only from RH6.0 and abov e) */

	/* Swap bytes in 16 bit value. */	/* Swap bytes in 16 bit value. */
	#define R__bswap_constant_16(x) \	#define R__bswap_constant_16(x) \
	((((x) >> 8) & 0xff) \| (((x) & 0xff) << 8))	((((x) >> 8) & 0xff) \| (((x) & 0xff) << 8))

	#if defined R__USEASMSWAP	#if defined R__USEASMSWAP
	# define R__bswap_16(x) \	# define R__bswap_16(x) \
	(__extension__ \	(__extension__ \

	({ register unsigned short int __v; \	({ unsigned short int __v; \
	if (__builtin_constant_p (x)) \	if (__builtin_constant_p (x)) \
	__v = R__bswap_constant_16 (x); \	__v = R__bswap_constant_16 (x); \
	else \	else \
	__asm__ __volatile__ ("rorw $8, %w0" \	__asm__ __volatile__ ("rorw $8, %w0" \
	: "=r" (__v) \	: "=r" (__v) \
	: "0" ((unsigned short int) (x)) \	: "0" ((unsigned short int) (x)) \
	: "cc"); \	: "cc"); \
	__v; }))	__v; }))
	#else	#else
	/* This is better than nothing. */	/* This is better than nothing. */

	skipping to change at line 76	skipping to change at line 76
	((((x) & 0xff000000) >> 24) \| (((x) & 0x00ff0000) >> 8) \| \	((((x) & 0xff000000) >> 24) \| (((x) & 0x00ff0000) >> 8) \| \
	(((x) & 0x0000ff00) << 8) \| (((x) & 0x000000ff) << 24))	(((x) & 0x0000ff00) << 8) \| (((x) & 0x000000ff) << 24))

	#if defined R__USEASMSWAP	#if defined R__USEASMSWAP
	/* To swap the bytes in a word the i486 processors and up provide the	/* To swap the bytes in a word the i486 processors and up provide the
	`bswap' opcode. On i386 we have to use three instructions. */	`bswap' opcode. On i386 we have to use three instructions. */
	# if !defined __i486__ && !defined __pentium__ && !defined __pentiumpro__ & & \	# if !defined __i486__ && !defined __pentium__ && !defined __pentiumpro__ & & \
	!defined __pentium4__ && !defined __x86_64__	!defined __pentium4__ && !defined __x86_64__
	# define R__bswap_32(x) \	# define R__bswap_32(x) \
	(__extension__ \	(__extension__ \

	({ register unsigned int __v; \	({ unsigned int __v; \
	if (__builtin_constant_p (x)) \	if (__builtin_constant_p (x)) \
	__v = R__bswap_constant_32 (x); \	__v = R__bswap_constant_32 (x); \
	else \	else \
	__asm__ __volatile__ ("rorw $8, %w0;" \	__asm__ __volatile__ ("rorw $8, %w0;" \
	"rorl $16, %0;" \	"rorl $16, %0;" \
	"rorw $8, %w0" \	"rorw $8, %w0" \
	: "=r" (__v) \	: "=r" (__v) \
	: "0" ((unsigned int) (x)) \	: "0" ((unsigned int) (x)) \
	: "cc"); \	: "cc"); \
	__v; }))	__v; }))
	# else	# else
	# define R__bswap_32(x) \	# define R__bswap_32(x) \
	(__extension__ \	(__extension__ \

	({ register unsigned int __v; \	({ unsigned int __v; \
	if (__builtin_constant_p (x)) \	if (__builtin_constant_p (x)) \
	__v = R__bswap_constant_32 (x); \	__v = R__bswap_constant_32 (x); \
	else \	else \
	__asm__ __volatile__ ("bswap %0" \	__asm__ __volatile__ ("bswap %0" \
	: "=r" (__v) \	: "=r" (__v) \
	: "0" ((unsigned int) (x))); \	: "0" ((unsigned int) (x))); \
	__v; }))	__v; }))
	# endif	# endif
	#else	#else
	# define R__bswap_32(x) R__bswap_constant_32 (x)	# define R__bswap_32(x) R__bswap_constant_32 (x)

End of changes. 3 change blocks.
	3 lines changed or deleted	3 lines changed or added

	Channel.h	Channel.h

	skipping to change at line 31	skipping to change at line 31

	namespace RooStats{	namespace RooStats{
	namespace HistFactory {	namespace HistFactory {

	class Channel {	class Channel {

	public:	public:
	friend class Measurement;	friend class Measurement;

	Channel();	Channel();

		Channel(const Channel& other);
	Channel(std::string Name, std::string InputFile="");	Channel(std::string Name, std::string InputFile="");

	// set name of channel	// set name of channel
	void SetName( const std::string& Name ) { fName = Name; }	void SetName( const std::string& Name ) { fName = Name; }
	// get name of channel	// get name of channel
	std::string GetName() { return fName; }	std::string GetName() { return fName; }
	// set name of input file containing histograms	// set name of input file containing histograms
	void SetInputFile( const std::string& file ) { fInputFile = file; }	void SetInputFile( const std::string& file ) { fInputFile = file; }
	// get name of input file	// get name of input file
	std::string GetInputFile() { return fInputFile; }	std::string GetInputFile() { return fInputFile; }

End of changes. 1 change blocks.
	0 lines changed or deleted	1 lines changed or added

	Data.h	Data.h

	skipping to change at line 30	skipping to change at line 30

	namespace RooStats{	namespace RooStats{
	namespace HistFactory {	namespace HistFactory {

	class Data {	class Data {

	public:	public:
	//friend class Channel;	//friend class Channel;

	Data();	Data();

		Data( const Data& other );
		/// constructor from name, file and path. Name of the histogram should no
		t include the path
	Data( std::string HistoName, std::string InputFile, std::string HistoPath ="" );	Data( std::string HistoName, std::string InputFile, std::string HistoPath ="" );

	std::string GetName() { return fName; }	std::string GetName() { return fName; }
	void SetName(const std::string& name) { fName=name; }	void SetName(const std::string& name) { fName=name; }

	void SetInputFile(const std::string& InputFile) { fInputFile = InputFile; }	void SetInputFile(const std::string& InputFile) { fInputFile = InputFile; }
	std::string GetInputFile() { return fInputFile; }	std::string GetInputFile() { return fInputFile; }

	void SetHistoName(const std::string& HistoName) { fHistoName = HistoName; }	void SetHistoName(const std::string& HistoName) { fHistoName = HistoName; }
	std::string GetHistoName() { return fHistoName; }	std::string GetHistoName() { return fHistoName; }

	skipping to change at line 60	skipping to change at line 62

	protected:	protected:

	std::string fName;	std::string fName;

	std::string fInputFile;	std::string fInputFile;
	std::string fHistoName;	std::string fHistoName;
	std::string fHistoPath;	std::string fHistoPath;

	// The Data Histogram	// The Data Histogram

	TRef fhData;	HistRef fhData;

	};	};

	}	}
	}	}

	#endif	#endif

End of changes. 2 change blocks.
	1 lines changed or deleted	4 lines changed or added

	FlexibleInterpVar.h	FlexibleInterpVar.h

	skipping to change at line 59	skipping to change at line 59
	void setHigh(RooAbsReal& param, Double_t newHigh);	void setHigh(RooAbsReal& param, Double_t newHigh);

	void printAllInterpCodes();	void printAllInterpCodes();

	virtual TObject* clone(const char* newname) const { return new Flexible InterpVar(*this, newname); }	virtual TObject* clone(const char* newname) const { return new Flexible InterpVar(*this, newname); }
	virtual ~FlexibleInterpVar() ;	virtual ~FlexibleInterpVar() ;

	virtual void printMultiline(ostream& os, Int_t contents, Bool_t verbose = kFALSE, TString indent = "") const;	virtual void printMultiline(ostream& os, Int_t contents, Bool_t verbose = kFALSE, TString indent = "") const;
	virtual void printFlexibleInterpVars(ostream& os) const;	virtual void printFlexibleInterpVars(ostream& os) const;


		private:

		double PolyInterpValue(int i, double x) const;

	protected:	protected:

	RooListProxy _paramList ;	RooListProxy _paramList ;
	Double_t _nominal;	Double_t _nominal;
	std::vector<double> _low;	std::vector<double> _low;
	std::vector<double> _high;	std::vector<double> _high;
	std::vector<int> _interpCode;	std::vector<int> _interpCode;
	Double_t _interpBoundary;	Double_t _interpBoundary;

	TIterator* _paramIter ; //! do not persist	TIterator* _paramIter ; //! do not persist


	mutable Bool_t _logInit ; //!	mutable Bool_t _logInit ; //! flag used for chaching
	mutable std::vector<double> _logLo ; //! cached logs	polynomial coefficients
	mutable std::vector<double> _logHi ; //! cached logs	mutable std::vector< double> _polCoeff; //! cached polynomial coef
	mutable std::vector<double> _powLo ; //! cached powers	ficients
	mutable std::vector<double> _powHi ; //! cached powers

	Double_t evaluate() const;	Double_t evaluate() const;

	ClassDef(RooStats::HistFactory::FlexibleInterpVar,2) // flexible interp olation	ClassDef(RooStats::HistFactory::FlexibleInterpVar,2) // flexible interp olation
	};	};
	}	}
	}	}

	#endif	#endif

End of changes. 2 change blocks.
	5 lines changed or deleted	8 lines changed or added

	FumiliFCNAdapter.h	FumiliFCNAdapter.h

	skipping to change at line 25	skipping to change at line 25
	#endif	#endif

	#ifndef ROOT_Math_FitMethodFunction	#ifndef ROOT_Math_FitMethodFunction
	#include "Math/FitMethodFunction.h"	#include "Math/FitMethodFunction.h"
	#endif	#endif

	#ifndef ROOT_Minuit2_MnPrint	#ifndef ROOT_Minuit2_MnPrint
	#include "Minuit2/MnPrint.h"	#include "Minuit2/MnPrint.h"
	#endif	#endif


	#ifndef ROOT_Math_Util	// #ifndef ROOT_Math_Util
	#include "Math/Util.h"	// #include "Math/Util.h"
	#endif	// #endif

	#include <cmath>	#include <cmath>

	namespace ROOT {	namespace ROOT {

	namespace Minuit2 {	namespace Minuit2 {

	/**	/**

	template wrapped class for adapting to FumiliFCNBase signature	template wrapped class for adapting to FumiliFCNBase signature

End of changes. 1 change blocks.
	3 lines changed or deleted	3 lines changed or added

	Functor.h	Functor.h

	skipping to change at line 32	skipping to change at line 32
	// #include "Math/StaticCheck.h"	// #include "Math/StaticCheck.h"
	// #endif	// #endif

	#include <memory>	#include <memory>

	namespace ROOT {	namespace ROOT {

	namespace Math {	namespace Math {

	/**	/**

		FunctorImpl is a base class for the functor
		handler implementation class.
		It defines the Copy operator used to clone the functor objects
		*/

		template<class IBaseFunc>
		class FunctorImpl : public IBaseFunc {

		public:

		typedef IBaseFunc BaseFunc;

		FunctorImpl() : IBaseFunc() { }

		virtual ~FunctorImpl() {}

		virtual FunctorImpl* Copy() const = 0;

		};

		/**
	Functor Handler class is responsible for wrapping any other functor and pointer to	Functor Handler class is responsible for wrapping any other functor and pointer to
	free C functions.	free C functions.
	It can be created from any function implementing the correct signature	It can be created from any function implementing the correct signature
	corresponding to the requested type	corresponding to the requested type
	In the case of one dimension the function evaluation object must impleme nt	In the case of one dimension the function evaluation object must impleme nt
	double operator() (double x). If it implements a method: double Derivat ive(double x)	double operator() (double x). If it implements a method: double Derivat ive(double x)
	can be used to create a Gradient function type.	can be used to create a Gradient function type.

	In the case of multi-dimension the function evaluation object must imple ment	In the case of multi-dimension the function evaluation object must imple ment
	double operator()(const double *x). If it implements a method:	double operator()(const double *x). If it implements a method:

	skipping to change at line 66	skipping to change at line 87

	// constructor for 1d functions	// constructor for 1d functions
	FunctorHandler(const Func & fun) : fDim(1), fFunc(fun) {}	FunctorHandler(const Func & fun) : fDim(1), fFunc(fun) {}

	// constructor for multi-dimensional functions w/0 NDim()	// constructor for multi-dimensional functions w/0 NDim()
	FunctorHandler(unsigned int dim, const Func & fun ) :	FunctorHandler(unsigned int dim, const Func & fun ) :
	fDim(dim),	fDim(dim),
	fFunc(fun)	fFunc(fun)
	{}	{}


		virtual ~FunctorHandler() {}

		// copy of the function handler (use copy-ctor)
		ImplFunc * Copy() const {
		return new FunctorHandler(*this);
		}

	// clone of the function handler (use copy-ctor)	// clone of the function handler (use copy-ctor)
	BaseFunc * Clone() const {	BaseFunc * Clone() const {

	return new FunctorHandler(*this);	return Copy();
	}	}

	// constructor for multi-dimensional functions	// constructor for multi-dimensional functions
	unsigned int NDim() const {	unsigned int NDim() const {
	return fDim;	return fDim;
	}	}

	private :	private :

	inline double DoEval (double x) const {	inline double DoEval (double x) const {

	skipping to change at line 135	skipping to change at line 163
	fGradFunc(gfun)	fGradFunc(gfun)
	{}	{}

	// constructor for multi-dimensional functions	// constructor for multi-dimensional functions
	FunctorGradHandler(unsigned int dim, const Func & fun, const GradFunc & gfun) :	FunctorGradHandler(unsigned int dim, const Func & fun, const GradFunc & gfun) :
	fDim(dim),	fDim(dim),
	fFunc(fun),	fFunc(fun),
	fGradFunc( gfun )	fGradFunc( gfun )
	{}	{}


		virtual ~FunctorGradHandler() {}

		// clone of the function handler (use copy-ctor)
		ImplFunc * Copy() const { return new FunctorGradHandler(*this); }

	// clone of the function handler (use copy-ctor)	// clone of the function handler (use copy-ctor)

	BaseFunc * Clone() const { return new FunctorGradHandler(*this); }	BaseFunc * Clone() const { return Copy(); }

	// constructor for multi-dimensional functions	// constructor for multi-dimensional functions
	unsigned int NDim() const {	unsigned int NDim() const {
	return fDim;	return fDim;
	}	}

	private :	private :

	inline double DoEval (double x) const {	inline double DoEval (double x) const {
	return fFunc(x);	return fFunc(x);

	skipping to change at line 196	skipping to change at line 229
	/// constructor from a pointer to the class and a pointer to the functio n	/// constructor from a pointer to the class and a pointer to the functio n
	MemFunHandler(const PointerToObj& pObj, PointerToMemFn pMemFn)	MemFunHandler(const PointerToObj& pObj, PointerToMemFn pMemFn)
	: fDim(1), fObj(pObj), fMemFn(pMemFn) // should pass pointer b y value ??	: fDim(1), fObj(pObj), fMemFn(pMemFn) // should pass pointer b y value ??
	{}	{}

	/// constructor from a pointer to the class and a pointer to the functio n	/// constructor from a pointer to the class and a pointer to the functio n
	MemFunHandler(unsigned int dim, const PointerToObj& pObj, PointerToMemFn pMemFn)	MemFunHandler(unsigned int dim, const PointerToObj& pObj, PointerToMemFn pMemFn)
	: fDim(dim), fObj(pObj), fMemFn(pMemFn)	: fDim(dim), fObj(pObj), fMemFn(pMemFn)
	{}	{}


		virtual ~MemFunHandler() {}

		// clone of the function handler (use copy-ctor)
		ImplFunc * Copy() const { return new MemFunHandler(*this); }

	// clone of the function handler (use copy-ctor)	// clone of the function handler (use copy-ctor)
	BaseFunc * Clone() const { return new MemFunHandler(*this); }	BaseFunc * Clone() const { return new MemFunHandler(*this); }

	// constructor for multi-dimensional functions	// constructor for multi-dimensional functions
	unsigned int NDim() const {	unsigned int NDim() const {
	return fDim;	return fDim;
	}	}

	private :	private :


	skipping to change at line 260	skipping to change at line 298
	MemGradFunHandler(unsigned int dim,	MemGradFunHandler(unsigned int dim,
	const PointerToObj& pObj,	const PointerToObj& pObj,
	PointerToMemFn pMemFn,	PointerToMemFn pMemFn,
	PointerToGradMemFn pGradMemFn )	PointerToGradMemFn pGradMemFn )
	: fDim(dim),	: fDim(dim),
	fObj(pObj),	fObj(pObj),
	fMemFn(pMemFn),	fMemFn(pMemFn),
	fGradMemFn(pGradMemFn)	fGradMemFn(pGradMemFn)
	{}	{}


		virtual ~MemGradFunHandler() {}

		// clone of the function handler (use copy-ctor)
		ImplFunc * Copy() const { return new MemGradFunHandler(*this); }

	// clone of the function handler (use copy-ctor)	// clone of the function handler (use copy-ctor)

	BaseFunc * Clone() const { return new MemGradFunHandler(*this); }	BaseFunc * Clone() const { return new MemGradFunHandler(*this); }

	// constructor for multi-dimensional functions	// constructor for multi-dimensional functions
	unsigned int NDim() const {	unsigned int NDim() const {
	return fDim;	return fDim;
	}	}

	private :	private :

	inline double DoEval (double x) const {	inline double DoEval (double x) const {
	return ((fObj).fMemFn)(x);	return ((fObj).fMemFn)(x);

	skipping to change at line 292	skipping to change at line 335
	inline double DoDerivative (const double * x, unsigned int icoord ) cons t {	inline double DoDerivative (const double * x, unsigned int icoord ) cons t {
	return ((fObj).fGradMemFn)(x,icoord);	return ((fObj).fGradMemFn)(x,icoord);
	}	}

	unsigned int fDim;	unsigned int fDim;
	mutable PointerToObj fObj;	mutable PointerToObj fObj;
	PointerToMemFn fMemFn;	PointerToMemFn fMemFn;
	PointerToGradMemFn fGradMemFn;	PointerToGradMemFn fGradMemFn;
	};	};


	#if defined(__MAKECINT__) \|\| defined(G__DICTIONARY)	//****************************
		// LM 7/2/2014: no needed this : make template ctor of Functor1D and GradF
		unctor1D not
		// available to CINT s
		//***************************************
		//#if defined(__MAKECINT__) \|\| defined(G__DICTIONARY)
	// needed since CINT initialize it with TRootIOCtor	// needed since CINT initialize it with TRootIOCtor
	//class TRootIOCtor;	//class TRootIOCtor;

	template<class ParentFunctor>
	class FunctorHandler<ParentFunctor,TRootIOCtor *> : public ParentFunctor::I
	mpl
	{
	public:
	typedef typename ParentFunctor::Impl ImplFunc;
	typedef typename ImplFunc::BaseFunc BaseFunc;


	FunctorHandler(TRootIOCtor *) {}	// template<class ParentFunctor>
	// function required by interface	// class FunctorHandler<ParentFunctor,TRootIOCtor *> : public ParentFunctor
	double DoEval (double ) const { return 0; }	::Impl
	double DoDerivative (double ) const { return 0; }	// {
	BaseFunc * Clone() const { return 0; }	// public:
		// typedef typename ParentFunctor::Impl ImplFunc;
		// typedef typename ImplFunc::BaseFunc BaseFunc;

		// FunctorHandler(TRootIOCtor *) {}
		// // function required by interface
		// virtual ~FunctorHandler() {}
		// double DoEval (double ) const { return 0; }
		// double DoDerivative (double ) const { return 0; }
		// ImplFunc * Copy() const { return 0; }
		// BaseFunc * Clone() const { return 0; }


	};	// };
	#endif	// #endif

	//_________________________________________________________________________ ______________________	//_________________________________________________________________________ ______________________
	/**	/**
	Documentation for class Functor class.	Documentation for class Functor class.
	It is used to wrap in a very simple and convenient way multi-dimensional function objects.	It is used to wrap in a very simple and convenient way multi-dimensional function objects.
	It can wrap all the following types:	It can wrap all the following types:
	<ul>	<ul>
	<li> any C++ callable object implemention double operator()( const doubl e * )	<li> any C++ callable object implemention double operator()( const doubl e * )
	<li> a free C function of type double ()(const double * )	<li> a free C function of type double ()(const double * )
	<li> a member function with the correct signature like Foo::Eval(const d ouble * ).	<li> a member function with the correct signature like Foo::Eval(const d ouble * ).

	skipping to change at line 331	skipping to change at line 381
	</ul>	</ul>
	The function dimension is required when constructing the functor.	The function dimension is required when constructing the functor.

	@ingroup GenFunc	@ingroup GenFunc

	*/	*/
	class Functor : public IBaseFunctionMultiDim {	class Functor : public IBaseFunctionMultiDim {

	public:	public:


	typedef IBaseFunctionMultiDim Impl;	typedef FunctorImpl<IBaseFunctionMultiDim> Impl;
	typedef IBaseFunctionMultiDim::BaseFunc ImplBase;	typedef IBaseFunctionMultiDim::BaseFunc ImplBase;

	/**	/**
	Default constructor	Default constructor
	*/	*/
	Functor () : fImpl(0) {}	Functor () : fImpl(0) {}

	/**	/**
	construct from a pointer to member function (multi-dim type)	construct from a pointer to member function (multi-dim type)
	*/	*/

	skipping to change at line 366	skipping to change at line 416
	//implement for interpreted CINT functions	//implement for interpreted CINT functions
	#if defined(__CINT__) \|\| defined(G__DICTIONARY) \|\| defined(MAKE_CINT_FUNCTO R)	#if defined(__CINT__) \|\| defined(G__DICTIONARY) \|\| defined(MAKE_CINT_FUNCTO R)
	Functor(void * p, unsigned int dim, const char * className = 0, const ch ar * methodName = 0);	Functor(void * p, unsigned int dim, const char * className = 0, const ch ar * methodName = 0);
	#endif	#endif

	/**	/**
	Destructor (no operations)	Destructor (no operations)
	*/	*/
	virtual ~Functor () {}	virtual ~Functor () {}


	#ifndef __CINT__
	/**	/**
	Copy constructor for functor based on ROOT::Math::IMultiGenFunction	Copy constructor for functor based on ROOT::Math::IMultiGenFunction
	*/	*/
	Functor(const Functor & rhs) :	Functor(const Functor & rhs) :

	Impl()	ImplBase()
	{	{
	if (rhs.fImpl.get() != 0)	if (rhs.fImpl.get() != 0)

	fImpl = std::auto_ptr<Impl>( (rhs.fImpl)->Clone() );	fImpl = std::auto_ptr<Impl>( (rhs.fImpl)->Copy() );
	}	}
	// need a specialization in order to call base classes and use clone	// need a specialization in order to call base classes and use clone


	#endif

	/**	/**
	Assignment operator	Assignment operator
	*/	*/
	Functor & operator = (const Functor & rhs) {	Functor & operator = (const Functor & rhs) {
	Functor copy(rhs);	Functor copy(rhs);
	// swap auto_ptr by hand	// swap auto_ptr by hand
	Impl * p = fImpl.release();	Impl * p = fImpl.release();
	fImpl.reset(copy.fImpl.release());	fImpl.reset(copy.fImpl.release());
	copy.fImpl.reset(p);	copy.fImpl.reset(p);
	return *this;	return *this;

	skipping to change at line 427	skipping to change at line 474
	</ul>	</ul>

	@ingroup GenFunc	@ingroup GenFunc

	*/	*/

	class Functor1D : public IBaseFunctionOneDim {	class Functor1D : public IBaseFunctionOneDim {

	public:	public:


	typedef IBaseFunctionOneDim Impl;	typedef FunctorImpl<IBaseFunctionOneDim> Impl;
	typedef IBaseFunctionOneDim::BaseFunc ImplBase;	typedef IBaseFunctionOneDim::BaseFunc ImplBase;

	/**	/**
	Default constructor	Default constructor
	*/	*/
	Functor1D () : fImpl(0) {}	Functor1D () : fImpl(0) {}


	/**	#ifndef __CINT__
	construct from a pointer to member function (1D type)
	*/
	template <class PtrObj, typename MemFn>
	Functor1D(const PtrObj& p, MemFn memFn)
	: fImpl(new MemFunHandler<Functor1D, PtrObj, MemFn>(p, memFn))
	{}

	/**	/**
	construct from a callable object with the right signature	construct from a callable object with the right signature
	implementing operator() (double x)	implementing operator() (double x)
	*/	*/
	template <typename Func>	template <typename Func>
	Functor1D(const Func & f) :	Functor1D(const Func & f) :
	fImpl(new FunctorHandler<Functor1D,Func>(f) )	fImpl(new FunctorHandler<Functor1D,Func>(f) )
	{}	{}

		#endif

		/**
		construct from a pointer to member function (1D type)
		*/
		template <class PtrObj, typename MemFn>
		Functor1D(const PtrObj& p, MemFn memFn)
		: fImpl(new MemFunHandler<Functor1D, PtrObj, MemFn>(p, memFn))
		{}

	//implement for interpreted CINT functions	//implement for interpreted CINT functions
	#if defined(__CINT__) \|\| defined(G__DICTIONARY) \|\| defined(MAKE_CINT_FUNCTO R)	#if defined(__CINT__) \|\| defined(G__DICTIONARY) \|\| defined(MAKE_CINT_FUNCTO R)
	Functor1D(void * p, const char * className = 0, const char * methodName = 0);	Functor1D(void * p, const char * className = 0, const char * methodName = 0);


	#endif	#endif

	/**	/**
	Destructor (no operations)	Destructor (no operations)
	*/	*/
	virtual ~Functor1D () {}	virtual ~Functor1D () {}


	#ifndef __CINT__

	/**	/**
	Copy constructor for Functor based on ROOT::Math::IGenFunction	Copy constructor for Functor based on ROOT::Math::IGenFunction
	*/	*/
	Functor1D(const Functor1D & rhs) :	Functor1D(const Functor1D & rhs) :

	// strange that this is required eventhough Impl is an abstract class	// strange that this is required eventhough ImplBase is an abstract c
	Impl()	lass
		ImplBase()
	{	{
	if (rhs.fImpl.get() != 0)	if (rhs.fImpl.get() != 0)

	fImpl = std::auto_ptr<Impl>( (rhs.fImpl)->Clone() );	fImpl = std::auto_ptr<Impl>( (rhs.fImpl)->Copy() );
	}	}

	#endif

	/**	/**
	Assignment operator	Assignment operator
	*/	*/
	Functor1D & operator = (const Functor1D & rhs) {	Functor1D & operator = (const Functor1D & rhs) {
	Functor1D copy(rhs);	Functor1D copy(rhs);
	// swap auto_ptr by hand	// swap auto_ptr by hand
	Impl * p = fImpl.release();	Impl * p = fImpl.release();
	fImpl.reset(copy.fImpl.release());	fImpl.reset(copy.fImpl.release());
	copy.fImpl.reset(p);	copy.fImpl.reset(p);

	skipping to change at line 525	skipping to change at line 572
	</ol>	</ol>
	The function dimension is required when constructing the functor.	The function dimension is required when constructing the functor.

	@ingroup GenFunc	@ingroup GenFunc

	*/	*/
	class GradFunctor : public IGradientFunctionMultiDim {	class GradFunctor : public IGradientFunctionMultiDim {

	public:	public:


	typedef IGradientFunctionMultiDim Impl;	typedef FunctorImpl<IGradientFunctionMultiDim> Impl;
	typedef IGradientFunctionMultiDim::BaseFunc ImplBase;	typedef IGradientFunctionMultiDim::BaseFunc ImplBase;

	/**	/**
	Default constructor	Default constructor
	*/	*/
	GradFunctor () : fImpl(0) {}	GradFunctor () : fImpl(0) {}

	/**	/**
	construct from a callable object of multi-dimension	construct from a callable object of multi-dimension
	implementing operator()(const double *x) and	implementing operator()(const double *x) and

	skipping to change at line 572	skipping to change at line 619
	#if defined(__CINT__) \|\| defined(G__DICTIONARY) \|\| defined(MAKE_CINT_FUNCTO R)	#if defined(__CINT__) \|\| defined(G__DICTIONARY) \|\| defined(MAKE_CINT_FUNCTO R)
	GradFunctor(void * p1, unsigned int dim, const char * className, const c har * methodName, const char * derivName);	GradFunctor(void * p1, unsigned int dim, const char * className, const c har * methodName, const char * derivName);
	GradFunctor(void * p1, void * p2, unsigned int dim);	GradFunctor(void * p1, void * p2, unsigned int dim);
	#endif	#endif

	/**	/**
	Destructor (no operations)	Destructor (no operations)
	*/	*/
	virtual ~GradFunctor () {}	virtual ~GradFunctor () {}


	#ifndef __CINT__

	/**	/**
	Copy constructor for functor based on ROOT::Math::IMultiGradFunction	Copy constructor for functor based on ROOT::Math::IMultiGradFunction
	*/	*/
	GradFunctor(const GradFunctor & rhs) :	GradFunctor(const GradFunctor & rhs) :

	ImplBase(),	ImplBase()
	Impl()
	{	{
	if (rhs.fImpl.get() != 0)	if (rhs.fImpl.get() != 0)

	fImpl = std::auto_ptr<Impl>( dynamic_cast<Impl *>( (rhs.fImpl)->Cl one()) );	fImpl = std::auto_ptr<Impl>( rhs.fImpl->Copy() );
	}	}

	#endif

	/**	/**
	Assignment operator	Assignment operator
	*/	*/
	GradFunctor & operator = (const GradFunctor & rhs) {	GradFunctor & operator = (const GradFunctor & rhs) {
	GradFunctor copy(rhs);	GradFunctor copy(rhs);
	// swap auto_ptr by hand	// swap auto_ptr by hand
	Impl * p = fImpl.release();	Impl * p = fImpl.release();
	fImpl.reset(copy.fImpl.release());	fImpl.reset(copy.fImpl.release());
	copy.fImpl.reset(p);	copy.fImpl.reset(p);

	skipping to change at line 641	skipping to change at line 684
	</ol>	</ol>

	@ingroup GenFunc	@ingroup GenFunc

	*/	*/

	class GradFunctor1D : public IGradientFunctionOneDim {	class GradFunctor1D : public IGradientFunctionOneDim {

	public:	public:


	typedef IGradientFunctionOneDim Impl;	typedef FunctorImpl<IGradientFunctionOneDim> Impl;
	typedef IGradientFunctionOneDim::BaseFunc ImplBase;	typedef IGradientFunctionOneDim::BaseFunc ImplBase;

	/**	/**
	Default constructor	Default constructor
	*/	*/
	GradFunctor1D () : fImpl(0) {}	GradFunctor1D () : fImpl(0) {}


		#ifndef __CINT__
	/**	/**
	construct from an object with the right signature	construct from an object with the right signature
	implementing both operator() (double x) and Derivative(double x)	implementing both operator() (double x) and Derivative(double x)
	*/	*/
	template <typename Func>	template <typename Func>
	GradFunctor1D(const Func & f) :	GradFunctor1D(const Func & f) :
	fImpl(new FunctorHandler<GradFunctor1D,Func>(f) )	fImpl(new FunctorHandler<GradFunctor1D,Func>(f) )
	{}	{}

		#endif

	/**	/**
	construct from a pointer to class and two pointers to member functio ns, one for	construct from a pointer to class and two pointers to member functio ns, one for
	the function evaluation and the other for the derivative.	the function evaluation and the other for the derivative.
	The member functions must take a double as argument and return a dou ble	The member functions must take a double as argument and return a dou ble
	*/	*/
	template <class PtrObj, typename MemFn, typename GradMemFn>	template <class PtrObj, typename MemFn, typename GradMemFn>
	GradFunctor1D(const PtrObj& p, MemFn memFn, GradMemFn gradFn)	GradFunctor1D(const PtrObj& p, MemFn memFn, GradMemFn gradFn)
	: fImpl(new MemGradFunHandler<GradFunctor1D, PtrObj, MemFn, GradMemFn >(p, memFn, gradFn))	: fImpl(new MemGradFunHandler<GradFunctor1D, PtrObj, MemFn, GradMemFn >(p, memFn, gradFn))
	{}	{}


		// eventually implement for interpreted CINT functions
		#if defined(__CINT__) \|\| defined(G__DICTIONARY) \|\| defined(MAKE_CINT_FUNCTO
		R)
		GradFunctor1D(void * p1, const char * className, const char * methodName
		, const char * derivName);
		GradFunctor1D(void * p1, void * p2);
		#endif

	/**	/**
	construct from two 1D function objects	construct from two 1D function objects
	*/	*/
	template <typename Func, typename GradFunc>	template <typename Func, typename GradFunc>
	GradFunctor1D(const Func & f, const GradFunc & g ) :	GradFunctor1D(const Func & f, const GradFunc & g ) :
	fImpl(new FunctorGradHandler<GradFunctor1D,Func, GradFunc>(f, g) )	fImpl(new FunctorGradHandler<GradFunctor1D,Func, GradFunc>(f, g) )
	{}	{}


	// eventually implement for interpreted CINT functions
	#if defined(__CINT__) \|\| defined(G__DICTIONARY) \|\| defined(MAKE_CINT_FUNCTO
	R)
	GradFunctor1D(void * p1, const char * className, const char * methodName
	, const char * derivName);
	GradFunctor1D(void * p1, void * p2);
	#endif

	/**	/**
	Destructor (no operations)	Destructor (no operations)
	*/	*/
	virtual ~GradFunctor1D () {}	virtual ~GradFunctor1D () {}


	#ifndef __CINT__

	/**	/**
	Copy constructor for Functor based on ROOT::Math::IGradFunction	Copy constructor for Functor based on ROOT::Math::IGradFunction
	*/	*/
	GradFunctor1D(const GradFunctor1D & rhs) :	GradFunctor1D(const GradFunctor1D & rhs) :
	// strange that this is required eventhough Impl is an abstract class	// strange that this is required eventhough Impl is an abstract class

	ImplBase(),	ImplBase()
	Impl()
	{	{
	if (rhs.fImpl.get() != 0)	if (rhs.fImpl.get() != 0)

	fImpl = std::auto_ptr<Impl>( dynamic_cast<Impl *>( (rhs.fImpl)->Cl one() ) );	fImpl = std::auto_ptr<Impl>( rhs.fImpl->Copy() );
	}	}

	#endif

	/**	/**
	Assignment operator	Assignment operator
	*/	*/
	GradFunctor1D & operator = (const GradFunctor1D & rhs) {	GradFunctor1D & operator = (const GradFunctor1D & rhs) {
	GradFunctor1D copy(rhs);	GradFunctor1D copy(rhs);
	// swap auto_ptr by hand	// swap auto_ptr by hand
	Impl * p = fImpl.release();	Impl * p = fImpl.release();
	fImpl.reset(copy.fImpl.release());	fImpl.reset(copy.fImpl.release());
	copy.fImpl.reset(p);	copy.fImpl.reset(p);

End of changes. 39 change blocks.
	61 lines changed or deleted	104 lines changed or added

	MatrixInversion.icc	MatrixInversion.icc

	skipping to change at line 560	skipping to change at line 560

	template <unsigned int idim, unsigned int n>	template <unsigned int idim, unsigned int n>
	template<class T>	template<class T>
	int Inverter<idim,n>::DfinvMatrix(MatRepStd<T,idim,n> & rhs,unsigned int * ir) {	int Inverter<idim,n>::DfinvMatrix(MatRepStd<T,idim,n> & rhs,unsigned int * ir) {

	typedef T* mIter;	typedef T* mIter;

	if (idim != n) return -1;	if (idim != n) return -1;

	double s31, s32;	double s31, s32;

	register double s33, s34;	double s33, s34;

	mIter m11 = rhs.Array();	mIter m11 = rhs.Array();
	mIter m12 = m11 + 1;	mIter m12 = m11 + 1;
	mIter m21 = m11 + n;	mIter m21 = m11 + n;
	mIter m22 = m12 + n;	mIter m22 = m12 + n;
	m21 = -(m22) * (m11) (*m21);	m21 = -(m22) * (m11) (*m21);
	m12 = -(m12);	m12 = -(m12);
	if (n>2) {	if (n>2) {
	mIter mi = rhs.Array() + 2 * n;	mIter mi = rhs.Array() + 2 * n;
	mIter mii= rhs.Array() + 2 * n + 2;	mIter mii= rhs.Array() + 2 * n + 2;

	skipping to change at line 611	skipping to change at line 611
	}	}
	}	}
	mIter mi = rhs.Array();	mIter mi = rhs.Array();
	mIter mii = rhs.Array();	mIter mii = rhs.Array();
	for (unsigned int i=1;i<n;i++) {	for (unsigned int i=1;i<n;i++) {
	unsigned int ni = n - i;	unsigned int ni = n - i;
	mIter mij = mi;	mIter mij = mi;
	//int j;	//int j;
	for (unsigned j=1; j<=i;j++) {	for (unsigned j=1; j<=i;j++) {
	s33 = *mij;	s33 = *mij;

	register mIter mikj = mi + n + j - 1;	mIter mikj = mi + n + j - 1;
	register mIter miik = mii + 1;	mIter miik = mii + 1;
	mIter min_end = mi + n;	mIter min_end = mi + n;
	for (;miik<min_end;) {	for (;miik<min_end;) {
	s33 += (mikj) (*(miik++));	s33 += (mikj) (*(miik++));
	mikj += n;	mikj += n;
	}	}
	*(mij++) = static_cast<T> ( s33 );	*(mij++) = static_cast<T> ( s33 );
	}	}
	for (unsigned j=1;j<=ni;j++) {	for (unsigned j=1;j<=ni;j++) {
	s34 = 0.0;	s34 = 0.0;
	mIter miik = mii + j;	mIter miik = mii + j;

End of changes. 2 change blocks.
	3 lines changed or deleted	3 lines changed or added

	Minuit2Minimizer.h	Minuit2Minimizer.h

	skipping to change at line 28	skipping to change at line 28
	#endif	#endif

	#ifndef ROOT_Minuit2_MnUserParameterState	#ifndef ROOT_Minuit2_MnUserParameterState
	#include "Minuit2/MnUserParameterState.h"	#include "Minuit2/MnUserParameterState.h"
	#endif	#endif

	#ifndef ROOT_Math_IFunctionfwd	#ifndef ROOT_Math_IFunctionfwd
	#include "Math/IFunctionfwd.h"	#include "Math/IFunctionfwd.h"
	#endif	#endif


	#ifndef ROOT_Math_IParamFunctionfwd
	#include "Math/IParamFunctionfwd.h"
	#endif

	namespace ROOT {	namespace ROOT {

	namespace Minuit2 {	namespace Minuit2 {

	class ModularFunctionMinimizer;	class ModularFunctionMinimizer;
	class FCNBase;	class FCNBase;
	class FunctionMinimum;	class FunctionMinimum;

	// enumeration specifying the type of Minuit2 minimizers	// enumeration specifying the type of Minuit2 minimizers
	enum EMinimizerType {	enum EMinimizerType {

End of changes. 1 change blocks.
	4 lines changed or deleted	0 lines changed or added

	MnPrint.h	MnPrint.h

	skipping to change at line 97	skipping to change at line 97

	#ifndef USE_ROOT_ERROR	#ifndef USE_ROOT_ERROR

	#ifndef MNLOG	#ifndef MNLOG
	#define MN_OS std::cerr	#define MN_OS std::cerr
	#else	#else
	#define MN_OS MNLOG	#define MN_OS MNLOG
	#endif	#endif

	#define MN_INFO_MSG(str) \	#define MN_INFO_MSG(str) \

	MN_OS << "Info: " << str \	if (MnPrint::Level() > 0) MN_OS << "Info: " << str \
	<< std::endl;	<< std::endl;
	#define MN_ERROR_MSG(str) \	#define MN_ERROR_MSG(str) \

	MN_OS << "Error: " << str \	if (MnPrint::Level() >= 0) MN_OS << "Error: " << str \
	<< std::endl;	<< std::endl;
	# define MN_INFO_VAL(x) \	# define MN_INFO_VAL(x) \

	MN_OS << "Info: " << #x << " = " << (x) << std::endl;	if (MnPrint::Level() > 0) MN_OS << "Info: " << #x << " = " << (x) << std ::endl;
	# define MN_ERROR_VAL(x) \	# define MN_ERROR_VAL(x) \

	MN_OS << "Error: " << #x << " = " << (x) << std::endl;	if (MnPrint::Level() >= 0) MN_OS << "Error: " << #x << " = " << (x) << s td::endl;

	// same giving a location	// same giving a location

	#define MN_INFO_MSG2(loc,str) \	#define MN_INFO_MSG2(loc,str) \

	MN_OS << "Info in " << loc << " : " << str \	if (MnPrint::Level() > 0) MN_OS << "Info in " << loc << " : " << str \
	<< std::endl;	<< std::endl;
	#define MN_ERROR_MSG2(loc,str) \	#define MN_ERROR_MSG2(loc,str) \

	MN_OS << "Error in " << loc << " : " << str \	if (MnPrint::Level() >= 0) MN_OS << "Error in " << loc << " : " << str \
	<< std::endl;	<< std::endl;
	# define MN_INFO_VAL2(loc,x) \	# define MN_INFO_VAL2(loc,x) \

	MN_OS << "Info in " << loc << " : " << #x << " = " << (x) << std::endl;	if (MnPrint::Level() > 0) MN_OS << "Info in " << loc << " : " << #x << " = " << (x) << std::endl;
	# define MN_ERROR_VAL2(loc,x) \	# define MN_ERROR_VAL2(loc,x) \

	MN_OS << "Error in " << loc << " : " << #x << " = " << (x) << std::endl;	if (MnPrint::Level() >= 0) MN_OS << "Error in " << loc << " : " << #x << " = " << (x) << std::endl;

	#else	#else
	// use ROOT error reporting system	// use ROOT error reporting system
	#include "TError.h"	#include "TError.h"
	#include "Math/Util.h"	#include "Math/Util.h"

	// this first two should be used only with string literals to	// this first two should be used only with string literals to
	// avoid warning produced by the format in TError	// avoid warning produced by the format in TError
	#define MN_INFO_MSG(str) \	#define MN_INFO_MSG(str) \
	::Info("Minuit2",str);	::Info("Minuit2",str);

End of changes. 8 change blocks.
	8 lines changed or deleted	8 lines changed or added

	MsgLogger.h	MsgLogger.h

	skipping to change at line 151	skipping to change at line 151
	(_f)(*this);	(_f)(*this);
	return *this;	return *this;
	}	}

	inline MsgLogger& MsgLogger::operator<< ( EMsgType type )	inline MsgLogger& MsgLogger::operator<< ( EMsgType type )
	{	{
	fActiveType = type;	fActiveType = type;
	return *this;	return *this;
	}	}


	// Although the proper definition of "Endl" as a function pointer	// Shortcut
	// would be nicer C++-wise, it introduces some "unused variable"	inline MsgLogger& Endl(MsgLogger& ml) { return MsgLogger::Endmsg(ml); }
	// warnings so let's use the #define definition after all...
	// static MsgLogger& ( *Endl )( MsgLogger& ) = &MsgLogger::Endmsg;
	#define Endl MsgLogger::Endmsg

	}	}

	#endif // TMVA_MsgLogger	#endif // TMVA_MsgLogger

End of changes. 1 change blocks.
	5 lines changed or deleted	2 lines changed or added

	RVersion.h	RVersion.h

	skipping to change at line 17	skipping to change at line 17
	* These macros can be used in the following way:	* These macros can be used in the following way:
	*	*
	* #if ROOT_VERSION_CODE >= ROOT_VERSION(2,23,4)	* #if ROOT_VERSION_CODE >= ROOT_VERSION(2,23,4)
	* #include <newheader.h>	* #include <newheader.h>
	* #else	* #else
	* #include <oldheader.h>	* #include <oldheader.h>
	* #endif	* #endif
	*	*
	*/	*/


	#define ROOT_RELEASE "5.34/14"	#define ROOT_RELEASE "5.34/17"
	#define ROOT_RELEASE_DATE "Dec 16 2013"	#define ROOT_RELEASE_DATE "Feb 24 2014"
	#define ROOT_RELEASE_TIME "11:46:38"	#define ROOT_RELEASE_TIME "08:54:05"
	#define ROOT_SVN_REVISION 49361	#define ROOT_SVN_REVISION 49361

	#define ROOT_GIT_COMMIT "v5-34-13-131-gd110ad3"	#define ROOT_GIT_COMMIT "v5-34-15-60-gba875ed"
	#define ROOT_GIT_BRANCH "heads/v5-34-00-patches"	#define ROOT_GIT_BRANCH "heads/v5-34-00-patches"

	#define ROOT_VERSION_CODE 336398	#define ROOT_VERSION_CODE 336401
	#define ROOT_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))	#define ROOT_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))

	#endif	#endif

End of changes. 3 change blocks.
	5 lines changed or deleted	5 lines changed or added

	RooCompositeDataStore.h	RooCompositeDataStore.h

	skipping to change at line 93	skipping to change at line 93
	virtual void attachBuffers(const RooArgSet& extObs) ;	virtual void attachBuffers(const RooArgSet& extObs) ;
	virtual void resetBuffers() ;	virtual void resetBuffers() ;

	// Constant term optimizer interface	// Constant term optimizer interface
	virtual void cacheArgs(const RooAbsArg* owner, RooArgSet& varSet, const R ooArgSet* nset=0, Bool_t skipZeroWeights=kFALSE) ;	virtual void cacheArgs(const RooAbsArg* owner, RooArgSet& varSet, const R ooArgSet* nset=0, Bool_t skipZeroWeights=kFALSE) ;
	virtual const RooAbsArg* cacheOwner() { return 0 ; }	virtual const RooAbsArg* cacheOwner() { return 0 ; }
	virtual void setArgStatus(const RooArgSet& set, Bool_t active) ;	virtual void setArgStatus(const RooArgSet& set, Bool_t active) ;
	virtual void resetCache() ;	virtual void resetCache() ;

	virtual void recalculateCache(const RooArgSet* /proj/, Int_t /firstEve nt/, Int_t /lastEvent/, Int_t /stepSize/, Bool_t /skipZeroWeights/) ;	virtual void recalculateCache(const RooArgSet* /proj/, Int_t /firstEve nt/, Int_t /lastEvent/, Int_t /stepSize/, Bool_t /skipZeroWeights/) ;

		virtual Bool_t hasFilledCache() const ;

	void loadValues(const RooAbsDataStore tds, const RooFormulaVar select=0 , const char* rangeName=0, Int_t nStart=0, Int_t nStop=2000000000) ;	void loadValues(const RooAbsDataStore tds, const RooFormulaVar select=0 , const char* rangeName=0, Int_t nStart=0, Int_t nStop=2000000000) ;


		virtual void forceCacheUpdate() ;

	protected:	protected:

	void attachCache(const RooAbsArg* newOwner, const RooArgSet& cachedVars) ;	void attachCache(const RooAbsArg* newOwner, const RooArgSet& cachedVars) ;

	std::map<Int_t,RooAbsDataStore*> _dataMap ;	std::map<Int_t,RooAbsDataStore*> _dataMap ;
	RooCategory* _indexCat ;	RooCategory* _indexCat ;
	mutable RooAbsDataStore* _curStore ; //! Datastore associated with curren t event	mutable RooAbsDataStore* _curStore ; //! Datastore associated with curren t event
	mutable Int_t _curIndex ; //! Index associated with current event	mutable Int_t _curIndex ; //! Index associated with current event
	Bool_t _ownComps ; //!	Bool_t _ownComps ; //!


End of changes. 2 change blocks.
	0 lines changed or deleted	3 lines changed or added

	RooFormulaVar.h	RooFormulaVar.h

	skipping to change at line 23	skipping to change at line 23
	* with or without modification, are permitted according to the terms *	* with or without modification, are permitted according to the terms *
	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
	************************************************************************ */	************************************************************************ */
	#ifndef ROO_FORMULA_VAR	#ifndef ROO_FORMULA_VAR
	#define ROO_FORMULA_VAR	#define ROO_FORMULA_VAR

	#include "RooAbsReal.h"	#include "RooAbsReal.h"
	#include "RooFormula.h"	#include "RooFormula.h"
	#include "RooArgList.h"	#include "RooArgList.h"
	#include "RooListProxy.h"	#include "RooListProxy.h"

		#include "RooTrace.h"

	class RooArgSet ;	class RooArgSet ;

	class RooFormulaVar : public RooAbsReal {	class RooFormulaVar : public RooAbsReal {
	public:	public:
	// Constructors, assignment etc	// Constructors, assignment etc

	inline RooFormulaVar() : _formula(0), _nset(0) { }	inline RooFormulaVar() : _formula(0), _nset(0) { TRACE_CREATE }
	RooFormulaVar(const char name, const char title, const char* formula, c onst RooArgList& dependents);	RooFormulaVar(const char name, const char title, const char* formula, c onst RooArgList& dependents);
	RooFormulaVar(const char name, const char title, const RooArgList& depe ndents);	RooFormulaVar(const char name, const char title, const RooArgList& depe ndents);
	RooFormulaVar(const RooFormulaVar& other, const char* name=0);	RooFormulaVar(const RooFormulaVar& other, const char* name=0);
	virtual TObject* clone(const char* newname) const { return new RooFormula Var(*this,newname); }	virtual TObject* clone(const char* newname) const { return new RooFormula Var(*this,newname); }
	virtual ~RooFormulaVar();	virtual ~RooFormulaVar();

	inline Bool_t ok() const { return formula().ok() ; }	inline Bool_t ok() const { return formula().ok() ; }

	inline RooAbsArg* getParameter(const char* name) const {	inline RooAbsArg* getParameter(const char* name) const {
	// Return pointer to parameter with given name	// Return pointer to parameter with given name

End of changes. 2 change blocks.
	1 lines changed or deleted	2 lines changed or added

	RooGaussian.h	RooGaussian.h

	skipping to change at line 21	skipping to change at line 21
	* *	* *
	* Redistribution and use in source and binary forms, *	* Redistribution and use in source and binary forms, *
	* with or without modification, are permitted according to the terms *	* with or without modification, are permitted according to the terms *
	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
	************************************************************************ */	************************************************************************ */
	#ifndef ROO_GAUSSIAN	#ifndef ROO_GAUSSIAN
	#define ROO_GAUSSIAN	#define ROO_GAUSSIAN

	#include "RooAbsPdf.h"	#include "RooAbsPdf.h"
	#include "RooRealProxy.h"	#include "RooRealProxy.h"

		#include "RooTrace.h"

	class RooRealVar;	class RooRealVar;

	class RooGaussian : public RooAbsPdf {	class RooGaussian : public RooAbsPdf {
	public:	public:

	RooGaussian() {} ;	RooGaussian() { TRACE_CREATE } ;
	RooGaussian(const char name, const char title,	RooGaussian(const char name, const char title,
	RooAbsReal& _x, RooAbsReal& _mean, RooAbsReal& _sigma);	RooAbsReal& _x, RooAbsReal& _mean, RooAbsReal& _sigma);
	RooGaussian(const RooGaussian& other, const char* name=0) ;	RooGaussian(const RooGaussian& other, const char* name=0) ;
	virtual TObject* clone(const char* newname) const { return new RooGaussia n(*this,newname); }	virtual TObject* clone(const char* newname) const { return new RooGaussia n(*this,newname); }

	inline virtual ~RooGaussian() { }	inline virtual ~RooGaussian() { TRACE_DESTROY }

	Int_t getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& analVars, cons t char* rangeName=0) const ;	Int_t getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& analVars, cons t char* rangeName=0) const ;
	Double_t analyticalIntegral(Int_t code, const char* rangeName=0) const ;	Double_t analyticalIntegral(Int_t code, const char* rangeName=0) const ;

	Int_t getGenerator(const RooArgSet& directVars, RooArgSet &generateVars, Bool_t staticInitOK=kTRUE) const;	Int_t getGenerator(const RooArgSet& directVars, RooArgSet &generateVars, Bool_t staticInitOK=kTRUE) const;
	void generateEvent(Int_t code);	void generateEvent(Int_t code);

	Double_t getLogVal(const RooArgSet* set) const ;	Double_t getLogVal(const RooArgSet* set) const ;

	protected:	protected:

End of changes. 3 change blocks.
	2 lines changed or deleted	3 lines changed or added

	RooGenCategory.h	RooGenCategory.h

	skipping to change at line 31	skipping to change at line 31
	#include "RooCategoryProxy.h"	#include "RooCategoryProxy.h"
	#include "RooCatType.h"	#include "RooCatType.h"

	#include "TString.h"	#include "TString.h"
	class TObject ;	class TObject ;
	#include "TMethodCall.h"	#include "TMethodCall.h"

	class RooGenCategory : public RooAbsCategory {	class RooGenCategory : public RooAbsCategory {
	public:	public:
	// Constructors etc.	// Constructors etc.

	inline RooGenCategory() {	inline RooGenCategory() : _map(0), _userFunc(0) {
	// Default constructor	// Default constructor
	// coverity[UNINIT_CTOR]	// coverity[UNINIT_CTOR]
	}	}
	RooGenCategory(const char name, const char title, void* userFunc, RooAr gSet& catList);	RooGenCategory(const char name, const char title, void* userFunc, RooAr gSet& catList);
	RooGenCategory(const RooGenCategory& other, const char *name=0) ;	RooGenCategory(const RooGenCategory& other, const char *name=0) ;
	virtual TObject* clone(const char* newname) const { return new RooGenCate gory(*this,newname); }	virtual TObject* clone(const char* newname) const { return new RooGenCate gory(*this,newname); }
	virtual ~RooGenCategory();	virtual ~RooGenCategory();

	// Printing interface (human readable)	// Printing interface (human readable)
	virtual void printMultiline(std::ostream& os, Int_t content, Bool_t verbo se=kFALSE, TString indent= "") const ;	virtual void printMultiline(std::ostream& os, Int_t content, Bool_t verbo se=kFALSE, TString indent= "") const ;

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	RooHistFunc.h	RooHistFunc.h

	skipping to change at line 23	skipping to change at line 23
	* with or without modification, are permitted according to the terms *	* with or without modification, are permitted according to the terms *
	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
	************************************************************************ */	************************************************************************ */
	#ifndef ROO_HIST_FUNC	#ifndef ROO_HIST_FUNC
	#define ROO_HIST_FUNC	#define ROO_HIST_FUNC

	#include "RooAbsReal.h"	#include "RooAbsReal.h"
	#include "RooRealProxy.h"	#include "RooRealProxy.h"
	#include "RooSetProxy.h"	#include "RooSetProxy.h"
	#include "RooAICRegistry.h"	#include "RooAICRegistry.h"

		#include "RooTrace.h"

	class RooRealVar;	class RooRealVar;
	class RooAbsReal;	class RooAbsReal;
	class RooDataHist ;	class RooDataHist ;

	class RooHistFunc : public RooAbsReal {	class RooHistFunc : public RooAbsReal {
	public:	public:
	RooHistFunc() ;	RooHistFunc() ;
	RooHistFunc(const char name, const char title, const RooArgSet& vars, c onst RooDataHist& dhist, Int_t intOrder=0);	RooHistFunc(const char name, const char title, const RooArgSet& vars, c onst RooDataHist& dhist, Int_t intOrder=0);

		RooHistFunc(const char name, const char title, const RooArgList& funcOb s, const RooArgList& histObs, const RooDataHist& dhist, Int_t intOrder=0);
	RooHistFunc(const RooHistFunc& other, const char* name=0);	RooHistFunc(const RooHistFunc& other, const char* name=0);
	virtual TObject* clone(const char* newname) const { return new RooHistFun c(*this,newname); }	virtual TObject* clone(const char* newname) const { return new RooHistFun c(*this,newname); }

	inline virtual ~RooHistFunc() { }	virtual ~RooHistFunc() ;

	RooDataHist& dataHist() {	RooDataHist& dataHist() {
	// Return RooDataHist that is represented	// Return RooDataHist that is represented
	return *_dataHist ;	return *_dataHist ;
	}	}
	const RooDataHist& dataHist() const {	const RooDataHist& dataHist() const {
	// Return RooDataHist that is represented	// Return RooDataHist that is represented
	return *_dataHist ;	return *_dataHist ;
	}	}


	skipping to change at line 77	skipping to change at line 79

	virtual Int_t getMaxVal(const RooArgSet& vars) const;	virtual Int_t getMaxVal(const RooArgSet& vars) const;
	virtual Double_t maxVal(Int_t code) const;	virtual Double_t maxVal(Int_t code) const;

	virtual std::list<Double_t>* binBoundaries(RooAbsRealLValue& /obs/, Dou ble_t /xlo/, Double_t /xhi/) const ;	virtual std::list<Double_t>* binBoundaries(RooAbsRealLValue& /obs/, Dou ble_t /xlo/, Double_t /xhi/) const ;
	virtual std::list<Double_t>* plotSamplingHint(RooAbsRealLValue& obs, Doub le_t xlo, Double_t xhi) const ;	virtual std::list<Double_t>* plotSamplingHint(RooAbsRealLValue& obs, Doub le_t xlo, Double_t xhi) const ;
	virtual Bool_t isBinnedDistribution(const RooArgSet&) const { return _int Order==0 ; }	virtual Bool_t isBinnedDistribution(const RooArgSet&) const { return _int Order==0 ; }

	protected:	protected:


		Bool_t redirectServersHook(const RooAbsCollection& newServerList, Bool_t mustReplaceAll, Bool_t nameChange, Bool_t isRecursive) ;
	Bool_t importWorkspaceHook(RooWorkspace& ws) ;	Bool_t importWorkspaceHook(RooWorkspace& ws) ;
	Bool_t areIdentical(const RooDataHist& dh1, const RooDataHist& dh2) ;	Bool_t areIdentical(const RooDataHist& dh1, const RooDataHist& dh2) ;

	Double_t evaluate() const;	Double_t evaluate() const;
	Double_t totalVolume() const ;	Double_t totalVolume() const ;
	friend class RooAbsCachedReal ;	friend class RooAbsCachedReal ;
	Double_t totVolume() const ;	Double_t totVolume() const ;


	RooSetProxy _depList ; // List of dependents defining dimensions	virtual void ioStreamerPass2() ;
	of histogram
		RooArgSet _histObsList ; // List of observables defining dimensio
		ns of histogram
		RooSetProxy _depList ; // List of observables mapped onto histogra
		m observables
		TIterator* _histObsIter ; //!
		TIterator* _pdfObsIter ; //!
	RooDataHist* _dataHist ; // Unowned pointer to underlying histogram	RooDataHist* _dataHist ; // Unowned pointer to underlying histogram
	mutable RooAICRegistry _codeReg ; //! Auxiliary class keeping tracking of analytical integration code	mutable RooAICRegistry _codeReg ; //! Auxiliary class keeping tracking of analytical integration code
	Int_t _intOrder ; // Interpolation order	Int_t _intOrder ; // Interpolation order
	Bool_t _cdfBoundaries ; // Use boundary conditions for CDFs.	Bool_t _cdfBoundaries ; // Use boundary conditions for CDFs.
	mutable Double_t _totVolume ; //! Total volume of space (product of rang es of observables)	mutable Double_t _totVolume ; //! Total volume of space (product of rang es of observables)
	Bool_t _unitNorm ; //! Assume contents is unit normalized (fo r use as pdf cache)	Bool_t _unitNorm ; //! Assume contents is unit normalized (fo r use as pdf cache)


	ClassDef(RooHistFunc,1) // Histogram based function	ClassDef(RooHistFunc,2) // Histogram based function
	};	};

	#endif	#endif

End of changes. 6 change blocks.
	4 lines changed or deleted	13 lines changed or added

	RooKeysPdf.h	RooKeysPdf.h

	skipping to change at line 56	skipping to change at line 56
	virtual Double_t maxVal(Int_t code) const;	virtual Double_t maxVal(Int_t code) const;

	void LoadDataSet( RooDataSet& data);	void LoadDataSet( RooDataSet& data);

	protected:	protected:

	RooRealProxy _x ;	RooRealProxy _x ;
	Double_t evaluate() const;	Double_t evaluate() const;

	private:	private:

		// how far you have to go out in a Gaussian until it is smaller than the
	Double_t evaluateFull(Double_t x) const;	// machine precision
		static const Double_t _nSigma; //!

	Int_t _nEvents;	Int_t _nEvents;
	Double_t *_dataPts; //[_nEvents]	Double_t *_dataPts; //[_nEvents]
	Double_t *_dataWgts; //[_nEvents]	Double_t *_dataWgts; //[_nEvents]
	Double_t *_weights; //[_nEvents]	Double_t *_weights; //[_nEvents]
	Double_t _sumWgt ;	Double_t _sumWgt ;

	enum { _nPoints = 1000 };	enum { _nPoints = 1000 };
	Double_t _lookupTable[_nPoints+1];	Double_t _lookupTable[_nPoints+1];


End of changes. 1 change blocks.
	2 lines changed or deleted	3 lines changed or added

	RooNormSetCache.h	RooNormSetCache.h

	skipping to change at line 19	skipping to change at line 19
	* Copyright (c) 2000-2005, Regents of the University of California *	* Copyright (c) 2000-2005, Regents of the University of California *
	* and Stanford University. All rights reserved. *	* and Stanford University. All rights reserved. *
	* *	* *
	* Redistribution and use in source and binary forms, *	* Redistribution and use in source and binary forms, *
	* with or without modification, are permitted according to the terms *	* with or without modification, are permitted according to the terms *
	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
	************************************************************************ */	************************************************************************ */
	#ifndef ROO_NORMSET_CACHE	#ifndef ROO_NORMSET_CACHE
	#define ROO_NORMSET_CACHE	#define ROO_NORMSET_CACHE


	#include "Riosfwd.h"	#include <utility>
	#include <assert.h>	#include <vector>
		#include <map>

	#include "Rtypes.h"	#include "Rtypes.h"

		#include "Riosfwd.h"
	#include "RooNameSet.h"	#include "RooNameSet.h"

	#include "RooSetPair.h"
	#include "RooHashTable.h"


	class RooArgSet ;	class RooAbsArg;
	class RooSetPair ;	class RooArgSet;

	typedef RooArgSet* pRooArgSet ;	typedef RooArgSet* pRooArgSet ;

	class RooNormSetCache {	class RooNormSetCache {

		protected:
		typedef std::pair<const RooArgSet, const RooArgSet> Pair;
		struct PairCmp {
		inline bool operator()(const Pair& a, const Pair& b) const
		{
		if (a.first < b.first) return true;
		if (b.first < a.first) return false;
		return a.second < b.second;
		}
		};
		typedef std::vector<Pair> PairVectType;
		typedef std::map<Pair, ULong_t> PairIdxMapType;

	public:	public:

	RooNormSetCache(Int_t regSize=32) ;	RooNormSetCache(ULong_t max = 32);
	RooNormSetCache(const RooNormSetCache& other) ;	virtual ~RooNormSetCache();
	virtual ~RooNormSetCache() ;

	void add(const RooArgSet* set1, const RooArgSet* set2=0) ;


	inline Int_t index(const RooArgSet* set1, const RooArgSet* set2=0, const TNamed* set2RangeName=0) {	void add(const RooArgSet* set1, const RooArgSet* set2 = 0);


		inline Int_t index(const RooArgSet* set1, const RooArgSet* set2 = 0,
		const TNamed* set2RangeName = 0)
		{
	// Match range name first	// Match range name first

	if (set2RangeName != _set2RangeName) return -1 ;	if (set2RangeName != _set2RangeName) return -1;
		const Pair pair(set1, set2);
	// Match pointer of sets	PairIdxMapType::const_iterator it = _pairToIdx.lower_bound(pair);
	Int_t i ;	if (_pairToIdx.end() != it &&
	for (i=0 ; i<_nreg ; i++) {	!PairCmp()(it->first, pair) && !PairCmp()(pair, it->first))
	if (_asArr[i]._set1 == set1 &&	return it->second;
	_asArr[i]._set2 == set2	return -1;
	) return i ;
	}

	return -1 ;
	}

	inline Bool_t contains(const RooArgSet* set1, const RooArgSet* set2=0, co
	nst TNamed* set2RangeName=0) {
	if (set2RangeName!=_set2RangeName) return kFALSE ;
	if (_htable) return (_htable->findSetPair(set1,set2)) ;
	return (index(set1,set2,set2RangeName)>=0) ;
	}	}


	inline Bool_t containsSet1(const RooArgSet* set1) {	inline Bool_t contains(const RooArgSet* set1, const RooArgSet* set2 = 0,
	Int_t i ;	const TNamed* set2RangeName = 0)
	for (i=0 ; i<_nreg ; i++) {	{ return (index(set1,set2,set2RangeName) >= 0); }
	if (_asArr[i]._set1 == set1) return kTRUE ;
	}	inline Bool_t containsSet1(const RooArgSet* set1)
	return kFALSE ;	{
		const Pair pair(set1, (const RooArgSet*)0);
		PairIdxMapType::const_iterator it = _pairToIdx.lower_bound(pair);
		if (_pairToIdx.end() != it && it->first.first == set1)
		return kTRUE;
		return kFALSE;
	}	}


	const RooArgSet* lastSet1() const { return _nreg>0?_asArr[_nreg-1]._set1:	const RooArgSet* lastSet1() const { return _pairs.empty()?0:_pairs.back()
	0 ; }	.first; }
	const RooArgSet* lastSet2() const { return _nreg>0?_asArr[_nreg-1]._set2:	const RooArgSet* lastSet2() const { return _pairs.empty()?0:_pairs.back()
	0 ; }	.second; }
	const RooNameSet& nameSet1() const { return _name1 ; }	const RooNameSet& nameSet1() const { return _name1; }
	const RooNameSet& nameSet2() const { return _name2 ; }	const RooNameSet& nameSet2() const { return _name2; }

		Bool_t autoCache(const RooAbsArg* self, const RooArgSet* set1,
		const RooArgSet* set2 = 0, const TNamed* set2RangeName = 0,
		Bool_t autoRefill = kTRUE);


	Bool_t autoCache(const RooAbsArg* self, const RooArgSet* set1, const RooA	void clear();
	rgSet* set2=0, const TNamed* set2RangeName=0, Bool_t autoRefill=kTRUE) ;	Int_t entries() const { return _pairs.size(); }


	void clear() ;	void initialize(const RooNormSetCache& other) { clear(); *this = other; }
	Int_t entries() const { return _nreg ; }

	void initialize(const RooNormSetCache& other) ;

	protected:	protected:


	void expand() ;	PairVectType _pairs; //!
		PairIdxMapType _pairToIdx; //!
	RooHashTable* _htable ; //! do not persist	ULong_t _max; //!
	Int_t _regSize ;	ULong_t _next; //!
	Int_t _nreg ;
	RooSetPair* _asArr ; //! do not persist	RooNameSet _name1; //!
		RooNameSet _name2; //!
	RooNameSet _name1 ; //!	TNamed* _set2RangeName; //!
	RooNameSet _name2 ; //!
	TNamed* _set2RangeName ; //!


	ClassDef(RooNormSetCache,1) // Management tool for tracking sets of simil	ClassDef(RooNormSetCache, 0) // Management tool for tracking sets of simi
	ar integration/normalization sets	lar integration/normalization sets
	} ;	};

	#endif	#endif

End of changes. 15 change blocks.
	61 lines changed or deleted	67 lines changed or added

	RooObjCacheManager.h	RooObjCacheManager.h

	skipping to change at line 53	skipping to change at line 53
	virtual void printCompactTreeHook(std::ostream&, const char *) ;	virtual void printCompactTreeHook(std::ostream&, const char *) ;
	virtual void findConstantNodes(const RooArgSet& /obs/, RooArgSet& /cac heList/, RooLinkedList& /processedNodes/) ;	virtual void findConstantNodes(const RooArgSet& /obs/, RooArgSet& /cac heList/, RooLinkedList& /processedNodes/) ;

	virtual void insertObjectHook(RooAbsCacheElement&) ;	virtual void insertObjectHook(RooAbsCacheElement&) ;

	void sterilize() ;	void sterilize() ;

	static void doClearObsList(Bool_t flag) { _clearObsList = flag ; }	static void doClearObsList(Bool_t flag) { _clearObsList = flag ; }
	static Bool_t clearObsList() { return _clearObsList ; }	static Bool_t clearObsList() { return _clearObsList ; }


		void setClearOnRedirect(Bool_t flag) { _clearOnRedirect = flag ; }

	protected:	protected:

	Bool_t _clearOnRedirect ;	Bool_t _clearOnRedirect ;
	Bool_t _optCacheModeSeen ; //!	Bool_t _optCacheModeSeen ; //!

	RooArgSet* _optCacheObservables ; //! current optCacheObservables	RooArgSet* _optCacheObservables ; //! current optCacheObservables

	static Bool_t _clearObsList ; // Clear obslist on sterilize?	static Bool_t _clearObsList ; // Clear obslist on sterilize?

	ClassDef(RooObjCacheManager,2) // Cache manager for generic caches that c ontain RooAbsArg objects	ClassDef(RooObjCacheManager,2) // Cache manager for generic caches that c ontain RooAbsArg objects

End of changes. 1 change blocks.
	0 lines changed or deleted	2 lines changed or added

	RooPoisson.h	RooPoisson.h

	skipping to change at line 17	skipping to change at line 17
	*********************************************************************** **/	*********************************************************************** **/

	#ifndef ROOPOISSON	#ifndef ROOPOISSON
	#define ROOPOISSON	#define ROOPOISSON

	#include "RooAbsPdf.h"	#include "RooAbsPdf.h"
	#include "RooRealProxy.h"	#include "RooRealProxy.h"
	#include "RooCategoryProxy.h"	#include "RooCategoryProxy.h"
	#include "RooAbsReal.h"	#include "RooAbsReal.h"
	#include "RooAbsCategory.h"	#include "RooAbsCategory.h"

		#include "RooTrace.h"

	class RooPoisson : public RooAbsPdf {	class RooPoisson : public RooAbsPdf {
	public:	public:

	RooPoisson() { _noRounding = kFALSE ; } ;	RooPoisson() { _noRounding = kFALSE ; TRACE_CREATE } ;
	RooPoisson(const char name, const char title, RooAbsReal& _x, RooAbsRea l& _mean, Bool_t noRounding=kFALSE);	RooPoisson(const char name, const char title, RooAbsReal& _x, RooAbsRea l& _mean, Bool_t noRounding=kFALSE);
	RooPoisson(const RooPoisson& other, const char* name=0) ;	RooPoisson(const RooPoisson& other, const char* name=0) ;
	virtual TObject* clone(const char* newname) const { return new RooPoisson (*this,newname); }	virtual TObject* clone(const char* newname) const { return new RooPoisson (*this,newname); }

	inline virtual ~RooPoisson() { }	inline virtual ~RooPoisson() { TRACE_DESTROY }

	Int_t getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& analVars, cons t char* rangeName=0) const ;	Int_t getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& analVars, cons t char* rangeName=0) const ;
	Double_t analyticalIntegral(Int_t code, const char* rangeName=0) const ;	Double_t analyticalIntegral(Int_t code, const char* rangeName=0) const ;

	Int_t getGenerator(const RooArgSet& directVars, RooArgSet &generateVars, Bool_t staticInitOK=kTRUE) const;	Int_t getGenerator(const RooArgSet& directVars, RooArgSet &generateVars, Bool_t staticInitOK=kTRUE) const;
	void generateEvent(Int_t code);	void generateEvent(Int_t code);

	void setNoRounding(bool flag = kTRUE){_noRounding = flag;}	void setNoRounding(bool flag = kTRUE){_noRounding = flag;}
	void protectNegativeMean(bool flag = kTRUE){_protectNegative = flag;}	void protectNegativeMean(bool flag = kTRUE){_protectNegative = flag;}


End of changes. 3 change blocks.
	2 lines changed or deleted	3 lines changed or added

	RooProdPdf.h	RooProdPdf.h

	skipping to change at line 122	skipping to change at line 122
	const RooLinkedList& terms, const RooLinkedList& n orms,	const RooLinkedList& terms, const RooLinkedList& n orms,
	const RooLinkedList& imps, const RooLinkedList& in ts, const RooLinkedList& cross) const ;	const RooLinkedList& imps, const RooLinkedList& in ts, const RooLinkedList& cross) const ;

	void getPartIntList(const RooArgSet* nset, const RooArgSet* iset, pRooArg List& partList, pRooLinkedList& nsetList,	void getPartIntList(const RooArgSet* nset, const RooArgSet* iset, pRooArg List& partList, pRooLinkedList& nsetList,
	Int_t& code, const char* isetRangeName=0) const ;	Int_t& code, const char* isetRangeName=0) const ;

	std::vector<RooAbsReal> processProductTerm(const RooArgSet nset, const RooArgSet* iset, const char* isetRangeName,	std::vector<RooAbsReal> processProductTerm(const RooArgSet nset, const RooArgSet* iset, const char* isetRangeName,
	const RooArgSet* term,const Ro oArgSet& termNSet, const RooArgSet& termISet,	const RooArgSet* term,const Ro oArgSet& termNSet, const RooArgSet& termISet,
	Bool_t& isOwned, Bool_t forceW rap=kFALSE) const ;	Bool_t& isOwned, Bool_t forceW rap=kFALSE) const ;


		virtual CacheMode canNodeBeCached() const { return RooAbsArg::NotAdvised
		; } ;
		virtual void setCacheAndTrackHints(RooArgSet&) ;

	// The cache object	// The cache object
	class CacheElem : public RooAbsCacheElement {	class CacheElem : public RooAbsCacheElement {
	public:	public:
	CacheElem() : _isRearranged(kFALSE), _rearrangedNum(0), _rearrangedDen( 0) {}	CacheElem() : _isRearranged(kFALSE), _rearrangedNum(0), _rearrangedDen( 0) {}
	virtual ~CacheElem() ;	virtual ~CacheElem() ;
	// Payload	// Payload
	RooArgList _partList ;	RooArgList _partList ;
	RooArgList _numList ;	RooArgList _numList ;
	RooArgList _denList ;	RooArgList _denList ;
	RooArgList _ownedList ;	RooArgList _ownedList ;

End of changes. 1 change blocks.
	0 lines changed or deleted	4 lines changed or added

	RooProduct.h	RooProduct.h

	skipping to change at line 56	skipping to change at line 56
	virtual ~RooProduct() ;	virtual ~RooProduct() ;

	class ProdMap ;	class ProdMap ;

	void printMetaArgs(std::ostream& os) const ;	void printMetaArgs(std::ostream& os) const ;

	virtual std::list<Double_t>* binBoundaries(RooAbsRealLValue& /obs/, Dou ble_t /xlo/, Double_t /xhi/) const ;	virtual std::list<Double_t>* binBoundaries(RooAbsRealLValue& /obs/, Dou ble_t /xlo/, Double_t /xhi/) const ;
	virtual std::list<Double_t>* plotSamplingHint(RooAbsRealLValue& /obs/, Double_t /xlo/, Double_t /xhi/) const ;	virtual std::list<Double_t>* plotSamplingHint(RooAbsRealLValue& /obs/, Double_t /xlo/, Double_t /xhi/) const ;
	virtual Bool_t isBinnedDistribution(const RooArgSet& obs) const ;	virtual Bool_t isBinnedDistribution(const RooArgSet& obs) const ;


		virtual CacheMode canNodeBeCached() const { return RooAbsArg::NotAdvised
		; } ;
		virtual void setCacheAndTrackHints(RooArgSet&) ;

	protected:	protected:

	RooListProxy _compRSet ;	RooListProxy _compRSet ;
	RooListProxy _compCSet ;	RooListProxy _compCSet ;
	TIterator* _compRIter ; //! do not persist	TIterator* _compRIter ; //! do not persist
	TIterator* _compCIter ; //! do not persist	TIterator* _compCIter ; //! do not persist

	class CacheElem : public RooAbsCacheElement {	class CacheElem : public RooAbsCacheElement {
	public:	public:
	virtual ~CacheElem();	virtual ~CacheElem();

End of changes. 1 change blocks.
	0 lines changed or deleted	4 lines changed or added

	RooRealSumPdf.h	RooRealSumPdf.h

	skipping to change at line 68	skipping to change at line 68

	virtual std::list<Double_t>* binBoundaries(RooAbsRealLValue& /obs/, Dou ble_t /xlo/, Double_t /xhi/) const ;	virtual std::list<Double_t>* binBoundaries(RooAbsRealLValue& /obs/, Dou ble_t /xlo/, Double_t /xhi/) const ;
	virtual std::list<Double_t>* plotSamplingHint(RooAbsRealLValue& /obs/, Double_t /xlo/, Double_t /xhi/) const ;	virtual std::list<Double_t>* plotSamplingHint(RooAbsRealLValue& /obs/, Double_t /xlo/, Double_t /xhi/) const ;
	Bool_t isBinnedDistribution(const RooArgSet& obs) const ;	Bool_t isBinnedDistribution(const RooArgSet& obs) const ;

	void setFloor(Bool_t flag) { _doFloor = flag ; }	void setFloor(Bool_t flag) { _doFloor = flag ; }
	Bool_t getFloor() const { return _doFloor ; }	Bool_t getFloor() const { return _doFloor ; }
	static void setFloorGlobal(Bool_t flag) { _doFloorGlobal = flag ; }	static void setFloorGlobal(Bool_t flag) { _doFloorGlobal = flag ; }
	static Bool_t getFloorGlobal() { return _doFloorGlobal ; }	static Bool_t getFloorGlobal() { return _doFloorGlobal ; }


		virtual CacheMode canNodeBeCached() const { return RooAbsArg::NotAdvised
		; } ;
		virtual void setCacheAndTrackHints(RooArgSet&) ;

	protected:	protected:

	class CacheElem : public RooAbsCacheElement {	class CacheElem : public RooAbsCacheElement {
	public:	public:
	CacheElem() {} ;	CacheElem() {} ;
	virtual ~CacheElem() {} ;	virtual ~CacheElem() {} ;
	virtual RooArgList containedArgs(Action) { RooArgList ret(_funcIntList) ; ret.add(_funcNormList) ; return ret ; }	virtual RooArgList containedArgs(Action) { RooArgList ret(_funcIntList) ; ret.add(_funcNormList) ; return ret ; }
	RooArgList _funcIntList ;	RooArgList _funcIntList ;
	RooArgList _funcNormList ;	RooArgList _funcNormList ;
	} ;	} ;

End of changes. 1 change blocks.
	0 lines changed or deleted	4 lines changed or added

	RooSetPair.h	RooSetPair.h

	skipping to change at line 19	skipping to change at line 19
	* Copyright (c) 2000-2005, Regents of the University of California *	* Copyright (c) 2000-2005, Regents of the University of California *
	* and Stanford University. All rights reserved. *	* and Stanford University. All rights reserved. *
	* *	* *
	* Redistribution and use in source and binary forms, *	* Redistribution and use in source and binary forms, *
	* with or without modification, are permitted according to the terms *	* with or without modification, are permitted according to the terms *
	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
	************************************************************************ */	************************************************************************ */
	#ifndef ROO_SET_PAIR	#ifndef ROO_SET_PAIR
	#define ROO_SET_PAIR	#define ROO_SET_PAIR


		#include <iostream>
	#include "TObject.h"	#include "TObject.h"
	#include "RooArgSet.h"	#include "RooArgSet.h"

	class RooLinkedListElem ;	class RooLinkedListElem ;
	class TBuffer ;	class TBuffer ;

	class RooSetPair : public TObject {	class RooSetPair : public TObject {
	public:	public:

	// Initial element ctor	// Initial element ctor

End of changes. 1 change blocks.
	0 lines changed or deleted	1 lines changed or added

	RooSharedPropertiesList.h	RooSharedPropertiesList.h

	skipping to change at line 23	skipping to change at line 23
	* with or without modification, are permitted according to the terms *	* with or without modification, are permitted according to the terms *
	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
	************************************************************************ */	************************************************************************ */
	#ifndef ROO_SHARED_PROPERTY_LIST	#ifndef ROO_SHARED_PROPERTY_LIST
	#define ROO_SHARED_PROPERTY_LIST	#define ROO_SHARED_PROPERTY_LIST

	#include "TObject.h"	#include "TObject.h"
	#include <assert.h>	#include <assert.h>
	#include "RooRefCountList.h"	#include "RooRefCountList.h"
	#include "RooSharedProperties.h"	#include "RooSharedProperties.h"

		#include <map>

	class RooSharedPropertiesList : public TObject {	class RooSharedPropertiesList : public TObject {
	public:	public:

	RooSharedPropertiesList() ;	RooSharedPropertiesList() ;
	virtual ~RooSharedPropertiesList() ;	virtual ~RooSharedPropertiesList() ;

	RooSharedProperties* registerProperties(RooSharedProperties*, Bool_t canD eleteIncoming=kTRUE) ;	RooSharedProperties* registerProperties(RooSharedProperties*, Bool_t canD eleteIncoming=kTRUE) ;
	void unregisterProperties(RooSharedProperties*) ;	void unregisterProperties(RooSharedProperties*) ;

	protected:	protected:

	RooRefCountList _propList ;	RooRefCountList _propList ;

		std::map<std::string, RooSharedProperties *> _newPropList;

	ClassDef(RooSharedPropertiesList,0) // Manager for shared properties amon g clones of certain RooAbsArg-derived types	ClassDef(RooSharedPropertiesList,0) // Manager for shared properties amon g clones of certain RooAbsArg-derived types
	};	};

	#endif	#endif

End of changes. 2 change blocks.
	0 lines changed or deleted	2 lines changed or added

	RooVectorDataStore.h	RooVectorDataStore.h

	skipping to change at line 249	skipping to change at line 249
	std::vector<Double_t> tmp;	std::vector<Double_t> tmp;
	tmp.reserve(std::max(siz, Int_t(4096 / sizeof(Double_t))));	tmp.reserve(std::max(siz, Int_t(4096 / sizeof(Double_t))));
	if (!_vec.empty())	if (!_vec.empty())
	tmp.assign(_vec.begin(), std::min(_vec.end(), _vec.begin() + siz ));	tmp.assign(_vec.begin(), std::min(_vec.end(), _vec.begin() + siz ));
	if (Int_t(tmp.size()) != siz)	if (Int_t(tmp.size()) != siz)
	tmp.resize(siz);	tmp.resize(siz);
	_vec.swap(tmp);	_vec.swap(tmp);
	} else {	} else {
	_vec.resize(siz);	_vec.resize(siz);
	}	}

	_vec0 = &_vec.front();	_vec0 = _vec.size() > 0 ? &_vec.front() : 0;
	}	}

	void reserve(Int_t siz) {	void reserve(Int_t siz) {
	_vec.reserve(siz);	_vec.reserve(siz);

	_vec0 = &_vec.front();	_vec0 = _vec.size() > 0 ? &_vec.front() : 0;
	}	}

	protected:	protected:
	std::vector<Double_t> _vec ;	std::vector<Double_t> _vec ;

	private:	private:
	friend class RooVectorDataStore ;	friend class RooVectorDataStore ;
	RooAbsReal* _nativeReal ;	RooAbsReal* _nativeReal ;
	RooAbsReal* _real ;	RooAbsReal* _real ;
	Double_t* _buf ; //!	Double_t* _buf ; //!

	skipping to change at line 537	skipping to change at line 537
	std::vector<RooCatType> tmp;	std::vector<RooCatType> tmp;
	tmp.reserve(std::max(siz, Int_t(4096 / sizeof(RooCatType))));	tmp.reserve(std::max(siz, Int_t(4096 / sizeof(RooCatType))));
	if (!_vec.empty())	if (!_vec.empty())
	tmp.assign(_vec.begin(), std::min(_vec.end(), _vec.begin() + siz ));	tmp.assign(_vec.begin(), std::min(_vec.end(), _vec.begin() + siz ));
	if (Int_t(tmp.size()) != siz)	if (Int_t(tmp.size()) != siz)
	tmp.resize(siz);	tmp.resize(siz);
	_vec.swap(tmp);	_vec.swap(tmp);
	} else {	} else {
	_vec.resize(siz);	_vec.resize(siz);
	}	}

	_vec0 = &_vec.front();	_vec0 = _vec.size() > 0 ? &_vec.front() : 0;
	}	}

	void reserve(Int_t siz) {	void reserve(Int_t siz) {
	_vec.reserve(siz);	_vec.reserve(siz);

	_vec0 = &_vec.front();	_vec0 = _vec.size() > 0 ? &_vec.front() : 0;
	}	}

	void setBufArg(RooAbsCategory* arg) { _cat = arg; }	void setBufArg(RooAbsCategory* arg) { _cat = arg; }
	const RooAbsCategory* bufArg() const { return _cat; }	const RooAbsCategory* bufArg() const { return _cat; }

	private:	private:
	friend class RooVectorDataStore ;	friend class RooVectorDataStore ;
	RooAbsCategory* _cat ;	RooAbsCategory* _cat ;
	RooCatType* _buf ; //!	RooCatType* _buf ; //!
	RooCatType* _nativeBuf ; //!	RooCatType* _nativeBuf ; //!

	skipping to change at line 707	skipping to change at line 707
	// If nothing found this will make an entry	// If nothing found this will make an entry
	_realfStoreList.push_back(new RealFullVector(real)) ;	_realfStoreList.push_back(new RealFullVector(real)) ;
	_nRealF++ ;	_nRealF++ ;

	// Update cached ptr to first element as push_back may have reallocated	// Update cached ptr to first element as push_back may have reallocated
	_firstRealF = &_realfStoreList.front() ;	_firstRealF = &_realfStoreList.front() ;

	return _realfStoreList.back() ;	return _realfStoreList.back() ;
	}	}


		virtual Bool_t hasFilledCache() const { return _cache ? kTRUE : kFALSE ;
		}

		void forceCacheUpdate() ;

	private:	private:
	RooArgSet _varsww ;	RooArgSet _varsww ;
	RooRealVar* _wgtVar ; // Pointer to weight variable (if set)	RooRealVar* _wgtVar ; // Pointer to weight variable (if set)

	std::vector<RealVector*> _realStoreList ;	std::vector<RealVector*> _realStoreList ;
	std::vector<RealFullVector*> _realfStoreList ;	std::vector<RealFullVector*> _realfStoreList ;
	std::vector<CatVector*> _catStoreList ;	std::vector<CatVector*> _catStoreList ;

	void setAllBuffersNative() ;	void setAllBuffersNative() ;


	skipping to change at line 740	skipping to change at line 744
	Double_t* _extSumW2Array ; //! External sum of weights array	Double_t* _extSumW2Array ; //! External sum of weights array

	mutable Double_t _curWgt ; // Weight of current event	mutable Double_t _curWgt ; // Weight of current event
	mutable Double_t _curWgtErrLo ; // Weight of current event	mutable Double_t _curWgtErrLo ; // Weight of current event
	mutable Double_t _curWgtErrHi ; // Weight of current event	mutable Double_t _curWgtErrHi ; // Weight of current event
	mutable Double_t _curWgtErr ; // Weight of current event	mutable Double_t _curWgtErr ; // Weight of current event

	RooVectorDataStore* _cache ; //! Optimization cache	RooVectorDataStore* _cache ; //! Optimization cache
	RooAbsArg* _cacheOwner ; //! Cache owner	RooAbsArg* _cacheOwner ; //! Cache owner


		Bool_t _forcedUpdate ; //! Request for forced cache update

	ClassDef(RooVectorDataStore,2) // STL-vector-based Data Storage class	ClassDef(RooVectorDataStore,2) // STL-vector-based Data Storage class
	};	};

	#endif	#endif

End of changes. 6 change blocks.
	4 lines changed or deleted	11 lines changed or added

	Sample.h	Sample.h

	skipping to change at line 19	skipping to change at line 19
	*************************************************************************/	*************************************************************************/

	#ifndef HISTFACTORY_SAMPLE_H	#ifndef HISTFACTORY_SAMPLE_H
	#define HISTFACTORY_SAMPLE_H	#define HISTFACTORY_SAMPLE_H

	#include <string>	#include <string>
	#include <fstream>	#include <fstream>
	#include <vector>	#include <vector>
	#include <iostream>	#include <iostream>


	#include "TRef.h"
	class TH1;	class TH1;


		#include "RooStats/HistFactory/HistRef.h"
	#include "RooStats/HistFactory/Systematics.h"	#include "RooStats/HistFactory/Systematics.h"

	namespace RooStats{	namespace RooStats{
	namespace HistFactory {	namespace HistFactory {

	class Sample {	class Sample {

	public:	public:

	Sample();	Sample();
	Sample(std::string Name);	Sample(std::string Name);

		Sample(const Sample& other);
		/// constructor from name, file and path. Name of the histogram should no
		t include the path
	Sample(std::string Name, std::string HistoName, std::string InputFile, st d::string HistoPath="");	Sample(std::string Name, std::string HistoName, std::string InputFile, st d::string HistoPath="");
	~Sample();	~Sample();

	void Print(std::ostream& = std::cout);	void Print(std::ostream& = std::cout);
	void PrintXML( std::ofstream& xml );	void PrintXML( std::ofstream& xml );
	void writeToFile( std::string FileName, std::string DirName );	void writeToFile( std::string FileName, std::string DirName );

	TH1* GetHisto();	TH1* GetHisto();
	// set histogram for this sample	// set histogram for this sample
	void SetHisto( TH1* histo ) { fhNominal = histo; fHistoName=histo->GetNam e(); }	void SetHisto( TH1* histo ) { fhNominal = histo; fHistoName=histo->GetNam e(); }
	void SetValue( Double_t Val );	void SetValue( Double_t Val );

	// Some helper functions	// Some helper functions

		/// Note that histogram name should not include the path of the histogram
		in the file.
		/// This has to be given separatly

	void ActivateStatError();	void ActivateStatError();
	void ActivateStatError( std::string HistoName, std::string InputFile, std ::string HistoPath="" );	void ActivateStatError( std::string HistoName, std::string InputFile, std ::string HistoPath="" );

	void AddOverallSys( std::string Name, Double_t Low, Double_t High );	void AddOverallSys( std::string Name, Double_t Low, Double_t High );
	void AddOverallSys( const OverallSys& Sys );	void AddOverallSys( const OverallSys& Sys );

	void AddNormFactor( std::string Name, Double_t Val, Double_t Low, Double_ t High, bool Const=false );	void AddNormFactor( std::string Name, Double_t Val, Double_t Low, Double_ t High, bool Const=false );
	void AddNormFactor( const NormFactor& Factor );	void AddNormFactor( const NormFactor& Factor );


	skipping to change at line 141	skipping to change at line 146
	std::vector< RooStats::HistFactory::ShapeSys > fShapeSysList;	std::vector< RooStats::HistFactory::ShapeSys > fShapeSysList;
	std::vector< RooStats::HistFactory::ShapeFactor > fShapeFactorList;	std::vector< RooStats::HistFactory::ShapeFactor > fShapeFactorList;

	// Properties	// Properties
	RooStats::HistFactory::StatError fStatError;	RooStats::HistFactory::StatError fStatError;

	bool fNormalizeByTheory;	bool fNormalizeByTheory;
	bool fStatErrorActivate;	bool fStatErrorActivate;

	// The Nominal Shape	// The Nominal Shape

	TRef fhNominal;	HistRef fhNominal;
	TH1* fhCountingHist;	TH1* fhCountingHist;

	};	};

	} // namespace HistFactory	} // namespace HistFactory
	} // namespace RooStats	} // namespace RooStats

	#endif	#endif

End of changes. 5 change blocks.
	2 lines changed or deleted	9 lines changed or added

	Systematics.h	Systematics.h

	skipping to change at line 19	skipping to change at line 19
	*************************************************************************/	*************************************************************************/

	#ifndef HISTFACTORY_SYSTEMATICS_H	#ifndef HISTFACTORY_SYSTEMATICS_H
	#define HISTFACTORY_SYSTEMATICS_H	#define HISTFACTORY_SYSTEMATICS_H

	#include <string>	#include <string>
	#include <fstream>	#include <fstream>
	#include <iostream>	#include <iostream>

	#include "TH1.h"	#include "TH1.h"

	#include "TRef.h"	#include "RooStats/HistFactory/HistRef.h"

	namespace RooStats{	namespace RooStats{
	namespace HistFactory {	namespace HistFactory {

	namespace Constraint {	namespace Constraint {
	enum Type{ Gaussian, Poisson };	enum Type{ Gaussian, Poisson };
	std::string Name( Type type );	std::string Name( Type type );
	Type GetType( const std::string& Name );	Type GetType( const std::string& Name );
	}	}


	skipping to change at line 149	skipping to change at line 149

	std::string fInputFileLow;	std::string fInputFileLow;
	std::string fHistoNameLow;	std::string fHistoNameLow;
	std::string fHistoPathLow;	std::string fHistoPathLow;

	std::string fInputFileHigh;	std::string fInputFileHigh;
	std::string fHistoNameHigh;	std::string fHistoNameHigh;
	std::string fHistoPathHigh;	std::string fHistoPathHigh;

	// The Low and High Histograms	// The Low and High Histograms

	TRef fhLow;	HistRef fhLow;
	TRef fhHigh;	HistRef fhHigh;

	};	};

	class HistoFactor {	class HistoFactor {

	public:	public:

	void SetName( const std::string& Name ) { fName = Name; }	void SetName( const std::string& Name ) { fName = Name; }
	std::string GetName() { return fName; }	std::string GetName() { return fName; }


	skipping to change at line 201	skipping to change at line 201

	std::string fInputFileLow;	std::string fInputFileLow;
	std::string fHistoNameLow;	std::string fHistoNameLow;
	std::string fHistoPathLow;	std::string fHistoPathLow;

	std::string fInputFileHigh;	std::string fInputFileHigh;
	std::string fHistoNameHigh;	std::string fHistoNameHigh;
	std::string fHistoPathHigh;	std::string fHistoPathHigh;

	// The Low and High Histograms	// The Low and High Histograms

	TRef fhLow;	HistRef fhLow;
	TRef fhHigh;	HistRef fhHigh;

	};	};

	class ShapeSys {	class ShapeSys {

	public:	public:

	void SetName( const std::string& Name ) { fName = Name; }	void SetName( const std::string& Name ) { fName = Name; }
	std::string GetName() { return fName; }	std::string GetName() { return fName; }


	skipping to change at line 241	skipping to change at line 241

	protected:	protected:

	std::string fName;	std::string fName;
	std::string fInputFile;	std::string fInputFile;
	std::string fHistoName;	std::string fHistoName;
	std::string fHistoPath;	std::string fHistoPath;
	Constraint::Type fConstraintType;	Constraint::Type fConstraintType;

	// The histogram holding the error	// The histogram holding the error

	TRef fhError;	HistRef fhError;

	};	};

	class ShapeFactor {	class ShapeFactor {

	public:	public:

	ShapeFactor();	ShapeFactor();

	void SetName( const std::string& Name ) { fName = Name; }	void SetName( const std::string& Name ) { fName = Name; }

	skipping to change at line 336	skipping to change at line 336

	protected:	protected:

	bool fActivate;	bool fActivate;
	bool fUseHisto; // Use an external histogram for the errors	bool fUseHisto; // Use an external histogram for the errors
	std::string fInputFile;	std::string fInputFile;
	std::string fHistoName;	std::string fHistoName;
	std::string fHistoPath;	std::string fHistoPath;

	// The histogram holding the error	// The histogram holding the error

	TRef fhError;	HistRef fhError;

	};	};

	class StatErrorConfig {	class StatErrorConfig {

	public:	public:

	StatErrorConfig() : fRelErrorThreshold( .05 ), fConstraintType( Constra int::Gaussian ) {;}	StatErrorConfig() : fRelErrorThreshold( .05 ), fConstraintType( Constra int::Gaussian ) {;}
	void Print(std::ostream& = std::cout);	void Print(std::ostream& = std::cout);
	void PrintXML(std::ostream&);	void PrintXML(std::ostream&);

End of changes. 5 change blocks.
	7 lines changed or deleted	7 lines changed or added

	TChainIndex.h	TChainIndex.h

	skipping to change at line 36	skipping to change at line 36
	//	//
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TVirtualIndex	#ifndef ROOT_TVirtualIndex
	#include "TVirtualIndex.h"	#include "TVirtualIndex.h"
	#endif	#endif

	#include <vector>	#include <vector>

	class TTreeFormula;	class TTreeFormula;

		class TTreeIndex;
	class TChain;	class TChain;

	class TChainIndex : public TVirtualIndex {	class TChainIndex : public TVirtualIndex {

	public:	public:
	class TChainIndexEntry {	class TChainIndexEntry {
	// holds a description of indices of trees in the chain.	// holds a description of indices of trees in the chain.
	public:	public:

	TChainIndexEntry() : fMinIndexValue(0), fMaxIndexValue(0), fTreeIndex	TChainIndexEntry() : fMinIndexValue(0), fMinIndexValMinor(0),
	(0) {}	fMaxIndexValue(0), fMaxIndexValMinor(0),
		fTreeIndex(0) {}
	Long64_t fMinIndexValue; // the minimum value of the ind
	ex	typedef std::pair<Long64_t, Long64_t> IndexValPair_t;
	Long64_t fMaxIndexValue; // the maximum value of the ind
	ex	IndexValPair_t GetMinIndexValPair() const { return IndexValPair_t(fMi
		nIndexValue, fMinIndexValMinor); }
		IndexValPair_t GetMaxIndexValPair() const { return IndexValPair_t(fMa
		xIndexValue, fMaxIndexValMinor); }
		void SetMinMaxFrom(const TTreeIndex *index );

		Long64_t fMinIndexValue; // the minimum value of the ind
		ex (upper bits)
		Long64_t fMinIndexValMinor; // the minimum value of the ind
		ex (lower bits)
		Long64_t fMaxIndexValue; // the maximum value of the ind
		ex (upper bits)
		Long64_t fMaxIndexValMinor; // the maximum value of the ind
		ex (lower bits)
	TVirtualIndex* fTreeIndex; // the tree index in case it wa s created in the constructor,	TVirtualIndex* fTreeIndex; // the tree index in case it wa s created in the constructor,
	// otherwise 0	// otherwise 0
	};	};
	protected:	protected:

	TString fMajorName; // Index major name	TString fMajorName; // Index major name
	TString fMinorName; // Index minor name	TString fMinorName; // Index minor name
	TTreeFormula *fMajorFormulaParent; //! Pointer to major TreeFormul a in Parent tree (if any)	TTreeFormula *fMajorFormulaParent; //! Pointer to major TreeFormul a in Parent tree (if any)
	TTreeFormula *fMinorFormulaParent; //! Pointer to minor TreeFormul a in Parent tree (if any)	TTreeFormula *fMinorFormulaParent; //! Pointer to minor TreeFormul a in Parent tree (if any)
	std::vector<TChainIndexEntry> fEntries; // descriptions of indices of tr ees in the chain.	std::vector<TChainIndexEntry> fEntries; // descriptions of indices of tr ees in the chain.


	std::pair<TVirtualIndex*, Int_t> GetSubTreeIndex(Int_t major, Int_t mino r) const;	std::pair<TVirtualIndex*, Int_t> GetSubTreeIndex(Long64_t major, Long64_ t minor) const;
	void ReleaseSubTreeIndex(TVirtualIndex* index, Int_t treeNo) const;	void ReleaseSubTreeIndex(TVirtualIndex* index, Int_t treeNo) const;
	void DeleteIndices();	void DeleteIndices();

	public:	public:
	TChainIndex();	TChainIndex();
	TChainIndex(const TTree T, const char majorname, const char *minorname );	TChainIndex(const TTree T, const char majorname, const char *minorname );
	virtual ~TChainIndex();	virtual ~TChainIndex();
	virtual void Append(const TVirtualIndex *, Bool_t delaySort = kFALSE);	virtual void Append(const TVirtualIndex *, Bool_t delaySort = kFALSE);
	virtual Long64_t GetEntryNumberFriend(const TTree *parent);	virtual Long64_t GetEntryNumberFriend(const TTree *parent);

	virtual Long64_t GetEntryNumberWithIndex(Int_t major, Int_t minor)	virtual Long64_t GetEntryNumberWithIndex(Long64_t major, Long64_t
	const;	minor) const;
	virtual Long64_t GetEntryNumberWithBestIndex(Int_t major, Int_t mi	virtual Long64_t GetEntryNumberWithBestIndex(Long64_t major, Long6
	nor) const;	4_t minor) const;
	const char *GetMajorName() const {return fMajorName.Data() ;}	const char *GetMajorName() const {return fMajorName.Data() ;}
	const char *GetMinorName() const {return fMinorName.Data() ;}	const char *GetMinorName() const {return fMinorName.Data() ;}
	virtual Long64_t GetN() const {return fEntries.size();}	virtual Long64_t GetN() const {return fEntries.size();}
	virtual TTreeFormula GetMajorFormulaParent(const TTree parent);	virtual TTreeFormula GetMajorFormulaParent(const TTree parent);
	virtual TTreeFormula GetMinorFormulaParent(const TTree parent);	virtual TTreeFormula GetMinorFormulaParent(const TTree parent);
	virtual void UpdateFormulaLeaves(const TTree *parent);	virtual void UpdateFormulaLeaves(const TTree *parent);
	virtual void SetTree(const TTree *T);	virtual void SetTree(const TTree *T);

	ClassDef(TChainIndex,1) //A Tree Index with majorname and minorname.	ClassDef(TChainIndex,1) //A Tree Index with majorname and minorname.
	};	};

End of changes. 4 change blocks.
	12 lines changed or deleted	26 lines changed or added

	TClass.h	TClass.h

	skipping to change at line 41	skipping to change at line 41
	#endif	#endif
	#ifndef ROOT_TObjString	#ifndef ROOT_TObjString
	#include "TObjString.h"	#include "TObjString.h"
	#endif	#endif
	#include <map>	#include <map>
	#include <string>	#include <string>

	class TBaseClass;	class TBaseClass;
	class TBrowser;	class TBrowser;
	class TDataMember;	class TDataMember;

	class TClassAttributeMap;
	class TClassRef;	class TClassRef;
	class TMethod;	class TMethod;
	class TRealData;	class TRealData;
	class TCint;	class TCint;
	class TBuffer;	class TBuffer;
	class TVirtualStreamerInfo;	class TVirtualStreamerInfo;
	class TVirtualCollectionProxy;	class TVirtualCollectionProxy;
	class TMethodCall;	class TMethodCall;
	class TVirtualIsAProxy;	class TVirtualIsAProxy;
	class TVirtualRefProxy;	class TVirtualRefProxy;

	skipping to change at line 142	skipping to change at line 141
	mutable Long_t fProperty; //!Property	mutable Long_t fProperty; //!Property
	mutable Bool_t fVersionUsed; //!Indicates whether GetClassVersio n has been called	mutable Bool_t fVersionUsed; //!Indicates whether GetClassVersio n has been called

	mutable Bool_t fIsOffsetStreamerSet; //!saved remember if fOffsetStr eamer has been set.	mutable Bool_t fIsOffsetStreamerSet; //!saved remember if fOffsetStr eamer has been set.
	mutable Long_t fOffsetStreamer; //!saved info to call Streamer	mutable Long_t fOffsetStreamer; //!saved info to call Streamer
	Int_t fStreamerType; //!cached of the streaming method t o use	Int_t fStreamerType; //!cached of the streaming method t o use
	mutable TVirtualStreamerInfo *fCurrentInfo; //!cached current st reamer info.	mutable TVirtualStreamerInfo *fCurrentInfo; //!cached current st reamer info.
	TClassRef *fRefStart; //!List of references to this objec t	TClassRef *fRefStart; //!List of references to this objec t
	TVirtualRefProxy *fRefProxy; //!Pointer to reference proxy if th is class represents a reference	TVirtualRefProxy *fRefProxy; //!Pointer to reference proxy if th is class represents a reference
	ROOT::TSchemaRuleSet *fSchemaRules; //! Schema evolution rules	ROOT::TSchemaRuleSet *fSchemaRules; //! Schema evolution rules

	TClassAttributeMap *fAttributeMap; //pointer to a class attribute map

	typedef void (TClass::StreamerImpl_t)(void obj, TBuffer &b, const TCla ss *onfile_class) const;	typedef void (TClass::StreamerImpl_t)(void obj, TBuffer &b, const TCla ss *onfile_class) const;
	mutable StreamerImpl_t fStreamerImpl;//! Pointer to the function impleme nting the right streaming behavior for the class represented by this object .	mutable StreamerImpl_t fStreamerImpl;//! Pointer to the function impleme nting the right streaming behavior for the class represented by this object .

	TMethod *GetClassMethod(Long_t faddr);	TMethod *GetClassMethod(Long_t faddr);
	TMethod GetClassMethod(const char name, const char *signatur e);	TMethod GetClassMethod(const char name, const char *signatur e);
	Int_t GetBaseClassOffsetRecurse(const TClass *base);	Int_t GetBaseClassOffsetRecurse(const TClass *base);
	void Init(const char name, Version_t cversion, const type_info info,	void Init(const char name, Version_t cversion, const type_info info,
	TVirtualIsAProxy *isa, ShowMembersFunc_t showmember,	TVirtualIsAProxy *isa, ShowMembersFunc_t showmember,
	const char dfil, const char ifil,	const char dfil, const char ifil,

	skipping to change at line 385	skipping to change at line 383
	void Store(TBuffer &b) const;	void Store(TBuffer &b) const;

	// Pseudo-method apply to the 'obj'. In particular those are used to	// Pseudo-method apply to the 'obj'. In particular those are used to
	// implement TObject like methods for non-TObject classes	// implement TObject like methods for non-TObject classes

	Int_t Browse(void obj, TBrowser b) const;	Int_t Browse(void obj, TBrowser b) const;
	void DeleteArray(void *ary, Bool_t dtorOnly = kFALSE);	void DeleteArray(void *ary, Bool_t dtorOnly = kFALSE);
	void Destructor(void *obj, Bool_t dtorOnly = kFALSE);	void Destructor(void *obj, Bool_t dtorOnly = kFALSE);
	void DynamicCast(const TClass base, void *obj, Bool_t up = kTRUE);	void DynamicCast(const TClass base, void *obj, Bool_t up = kTRUE);
	Bool_t IsFolder(void *obj) const;	Bool_t IsFolder(void *obj) const;

	void CreateAttributeMap();
	TClassAttributeMap *GetAttributeMap() const
	{
	//Get the TClassAttributeMap pointer to be able to add attribute
	//pairs key-value to the TClass.

	return fAttributeMap;
	}
	inline void Streamer(void obj, TBuffer &b, const TClass onfile_ class = 0) const	inline void Streamer(void obj, TBuffer &b, const TClass onfile_ class = 0) const
	{	{
	// Inline for performance, skipping one function call.	// Inline for performance, skipping one function call.
	(this->*fStreamerImpl)(obj,b,onfile_class);	(this->*fStreamerImpl)(obj,b,onfile_class);
	}	}

	ClassDef(TClass,0) //Dictionary containing class information	ClassDef(TClass,0) //Dictionary containing class information
	};	};

	namespace ROOT {	namespace ROOT {

End of changes. 3 change blocks.
	10 lines changed or deleted	0 lines changed or added

	TDictionary.h	TDictionary.h

	skipping to change at line 49	skipping to change at line 49
	// TMethodCall (method call environment) //	// TMethodCall (method call environment) //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TNamed	#ifndef ROOT_TNamed
	#include "TNamed.h"	#include "TNamed.h"
	#endif	#endif

	#include "Property.h"	#include "Property.h"


		class TDictAttributeMap;

	typedef void CallFunc_t;	typedef void CallFunc_t;
	typedef void ClassInfo_t;	typedef void ClassInfo_t;
	typedef void BaseClassInfo_t;	typedef void BaseClassInfo_t;
	typedef void DataMemberInfo_t;	typedef void DataMemberInfo_t;
	typedef void MethodInfo_t;	typedef void MethodInfo_t;
	typedef void MethodArgInfo_t;	typedef void MethodArgInfo_t;
	typedef void MethodArgInfo_t;	typedef void MethodArgInfo_t;
	typedef void TypeInfo_t;	typedef void TypeInfo_t;
	typedef void TypedefInfo_t;	typedef void TypedefInfo_t;


	skipping to change at line 90	skipping to change at line 92
	kIsUsingVariable= G__BIT_ISUSINGVARIABLE,	kIsUsingVariable= G__BIT_ISUSINGVARIABLE,
	kIsDefault = G__BIT_ISDEFAULT,	kIsDefault = G__BIT_ISDEFAULT,
	kIsReference = G__BIT_ISREFERENCE,	kIsReference = G__BIT_ISREFERENCE,
	kIsConstant = G__BIT_ISCONSTANT,	kIsConstant = G__BIT_ISCONSTANT,
	kIsConstPointer = G__BIT_ISPCONSTANT,	kIsConstPointer = G__BIT_ISPCONSTANT,
	kIsMethConst = G__BIT_ISMETHCONSTANT	kIsMethConst = G__BIT_ISMETHCONSTANT
	};	};

	class TDictionary : public TNamed {	class TDictionary : public TNamed {


	public:	private:
	TDictionary() { }	TDictAttributeMap *fAttributeMap; //pointer to a dictionary attribute
	TDictionary(const char* name): TNamed(name, "") { }	map
	virtual ~TDictionary() { }


		public:
		TDictionary(): fAttributeMap(0) { }
		TDictionary(const char* name): TNamed(name, ""), fAttributeMap(0) { }
		TDictionary(const TDictionary& dict);
		virtual ~TDictionary();

		void CreateAttributeMap();
		TDictAttributeMap *GetAttributeMap() const
		{
		//Get the TDictAttributeMap pointer to be able to add attribute
		//pairs key-value to the TClass.
		return fAttributeMap;
		}
	virtual Long_t Property() const = 0;	virtual Long_t Property() const = 0;
	static TDictionary* GetDictionary(const char* name);	static TDictionary* GetDictionary(const char* name);
	static TDictionary* GetDictionary(const type_info &typeinfo);	static TDictionary* GetDictionary(const type_info &typeinfo);

	// Type of STL container (returned by IsSTLContainer).	// Type of STL container (returned by IsSTLContainer).
	enum ESTLType {	enum ESTLType {
	kNone = ROOT::kNotSTL,	kNone = ROOT::kNotSTL,
	kVector = ROOT::kSTLvector,	kVector = ROOT::kSTLvector,
	kList = ROOT::kSTLlist,	kList = ROOT::kSTLlist,
	kDeque = ROOT::kSTLdeque,	kDeque = ROOT::kSTLdeque,

End of changes. 3 change blocks.
	4 lines changed or deleted	18 lines changed or added

	TEveDigitSetEditor.h	TEveDigitSetEditor.h

	// @(#)root/eve:$Id$	// @(#)root/eve:$Id: 2e075f81994f9a7eca182d23ab52b081eda5c617 $
	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 58	skipping to change at line 58
	UInt_t options = kChildFrame, Pixel_t back=GetDefault FrameBackground());	UInt_t options = kChildFrame, Pixel_t back=GetDefault FrameBackground());
	virtual ~TEveDigitSetEditor() {}	virtual ~TEveDigitSetEditor() {}

	virtual void SetModel(TObject* obj);	virtual void SetModel(TObject* obj);

	// Declare callback/slot methods	// Declare callback/slot methods
	void DoHisto();	void DoHisto();
	void DoRangeHisto();	void DoRangeHisto();
	void PlotHisto(Int_t min, Int_t max);	void PlotHisto(Int_t min, Int_t max);


	ClassDef(TEveDigitSetEditor, 1); // Editor for TEveDigitSet class.	ClassDef(TEveDigitSetEditor, 0); // Editor for TEveDigitSet class.
	};	};

	#endif	#endif

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	TFormLeafInfo.h	TFormLeafInfo.h

	skipping to change at line 28	skipping to change at line 28

	#ifndef ROOT_TLeafElement	#ifndef ROOT_TLeafElement
	#include "TLeafElement.h"	#include "TLeafElement.h"
	#endif	#endif

	#include "TArrayI.h"	#include "TArrayI.h"
	#include "TDataType.h"	#include "TDataType.h"
	#include "TStreamerInfo.h"	#include "TStreamerInfo.h"
	#include "TStreamerElement.h"	#include "TStreamerElement.h"


		// declare the extra versions of GetValue() plus templated implementation
		#define DECLARE_GETVAL \
		virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0)
		\
		{ return GetValueImpl<Double_t>(leaf, instance); }
		\
		virtual Long64_t GetValueLong64(TLeaf *leaf, Int_t instance = 0)
		\
		{ return GetValueImpl<Long64_t>(leaf, instance); }
		\
		virtual LongDouble_t GetValueLongDouble(TLeaf *leaf, Int_t instance = 0
		) \
		{ return GetValueImpl<LongDouble_t>(leaf, instance); }
		\
		template<typename T> T GetValueImpl(TLeaf *leaf, Int_t instance = 0)
		// no semicolon

		// declare the extra versions of ReadValue() plus templated implementation
		#define DECLARE_READVAL \
		virtual Double_t ReadValue(char *where, Int_t instance = 0)
		\
		{ return ReadValueImpl<Double_t>(where, instance); }
		\
		virtual Long64_t ReadValueLong64(char *where, Int_t instance = 0)
		\
		{ return ReadValueImpl<Long64_t>(where, instance); }
		\
		virtual LongDouble_t ReadValueLongDouble(char *where, Int_t instance = 0
		) \
		{ return ReadValueImpl<LongDouble_t>(where, instance); }
		\
		template<typename T> T ReadValueImpl(char *where, Int_t instance = 0)
		// no semicolon

	class TFormLeafInfo : public TObject {	class TFormLeafInfo : public TObject {
	public:	public:
	// Constructors	// Constructors
	TFormLeafInfo(TClass* classptr = 0, Long_t offset = 0,	TFormLeafInfo(TClass* classptr = 0, Long_t offset = 0,
	TStreamerElement* element = 0);	TStreamerElement* element = 0);
	TFormLeafInfo(const TFormLeafInfo& orig);	TFormLeafInfo(const TFormLeafInfo& orig);
	virtual TFormLeafInfo* DeepCopy() const;	virtual TFormLeafInfo* DeepCopy() const;
	virtual ~TFormLeafInfo();	virtual ~TFormLeafInfo();

	void Swap(TFormLeafInfo &other);	void Swap(TFormLeafInfo &other);

	skipping to change at line 71	skipping to change at line 91
	virtual Int_t ReadCounterValue(char *where);	virtual Int_t ReadCounterValue(char *where);

	char* GetObjectAddress(TLeafElement* leaf, Int_t &instance);	char* GetObjectAddress(TLeafElement* leaf, Int_t &instance);

	Int_t GetMultiplicity();	Int_t GetMultiplicity();

	// Currently only implemented in TFormLeafInfoCast	// Currently only implemented in TFormLeafInfoCast
	Int_t GetNdata(TLeaf* leaf);	Int_t GetNdata(TLeaf* leaf);
	virtual Int_t GetNdata();	virtual Int_t GetNdata();


	virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0);

	virtual void GetValuePointer(TLeaf leaf, Int_t instance = 0);	virtual void GetValuePointer(TLeaf leaf, Int_t instance = 0);
	virtual void GetValuePointer(char from, Int_t instance = 0);	virtual void GetValuePointer(char from, Int_t instance = 0);
	virtual void GetLocalValuePointer(TLeaf leaf, Int_t instance = 0);	virtual void GetLocalValuePointer(TLeaf leaf, Int_t instance = 0);
	virtual void GetLocalValuePointer( char from, Int_t instance = 0);	virtual void GetLocalValuePointer( char from, Int_t instance = 0);

	virtual Bool_t HasCounter() const;	virtual Bool_t HasCounter() const;
	virtual Bool_t IsString() const;	virtual Bool_t IsString() const;

	virtual Bool_t IsInteger() const;	virtual Bool_t IsInteger() const;
	virtual Bool_t IsReference() const { return kFALSE; }	virtual Bool_t IsReference() const { return kFALSE; }

	skipping to change at line 97	skipping to change at line 115
	virtual Int_t GetVirtVarDim();	virtual Int_t GetVirtVarDim();
	virtual Int_t GetSize(Int_t index);	virtual Int_t GetSize(Int_t index);
	virtual Int_t GetSumOfSizes();	virtual Int_t GetSumOfSizes();
	virtual void LoadSizes(TBranch* branch);	virtual void LoadSizes(TBranch* branch);
	virtual void SetPrimaryIndex(Int_t index);	virtual void SetPrimaryIndex(Int_t index);
	virtual void SetSecondaryIndex(Int_t index);	virtual void SetSecondaryIndex(Int_t index);
	virtual void SetSize(Int_t index, Int_t val);	virtual void SetSize(Int_t index, Int_t val);
	virtual void SetBranch(TBranch* br) { if ( fNext ) fNext->SetBranch(br ); }	virtual void SetBranch(TBranch* br) { if ( fNext ) fNext->SetBranch(br ); }
	virtual void UpdateSizes(TArrayI *garr);	virtual void UpdateSizes(TArrayI *garr);


	virtual Double_t ReadValue(char *where, Int_t instance = 0);

	virtual Bool_t Update();	virtual Bool_t Update();


		DECLARE_GETVAL;
		DECLARE_READVAL;

		template <typename T> struct ReadValueHelper {
		static T Exec(TFormLeafInfo leaf, char where, Int_t instance) {
		return leaf->ReadValue(where, instance);
		}
		};
		template <typename T > T ReadTypedValue(char *where, Int_t instance = 0)
		{
		return ReadValueHelper<T>::Exec(this, where, instance);
		}

		template <typename T> struct GetValueHelper {
		static T Exec(TFormLeafInfo linfo, TLeaf leaf, Int_t instance) {
		return linfo->GetValue(leaf, instance);
		}
		};
		template <typename T > T GetTypedValue(TLeaf *leaf, Int_t instance = 0)
		{
		return GetValueHelper<T>::Exec(this, leaf, instance);
		}
		};

		template <> struct TFormLeafInfo::ReadValueHelper<Long64_t> {
		static Long64_t Exec(TFormLeafInfo leaf, char where, Int_t instance) {
		return leaf->ReadValueLong64(where, instance); }
		};
		template <> struct TFormLeafInfo::ReadValueHelper<ULong64_t> {
		static ULong64_t Exec(TFormLeafInfo leaf, char where, Int_t instance)
		{ return (ULong64_t)leaf->ReadValueLong64(where, instance); }
		};
		template <> struct TFormLeafInfo::ReadValueHelper<LongDouble_t> {
		static LongDouble_t Exec(TFormLeafInfo leaf, char where, Int_t instanc
		e) { return leaf->ReadValueLongDouble(where, instance); }
		};

		template <> struct TFormLeafInfo::GetValueHelper<Long64_t> {
		static Long64_t Exec(TFormLeafInfo linfo, TLeaf leaf, Int_t instance)
		{ return linfo->GetValueLong64(leaf, instance); }
		};
		template <> struct TFormLeafInfo::GetValueHelper<ULong64_t> {
		static ULong64_t Exec(TFormLeafInfo linfo, TLeaf leaf, Int_t instance)
		{ return (ULong64_t)linfo->GetValueLong64(leaf, instance); }
		};
		template <> struct TFormLeafInfo::GetValueHelper<LongDouble_t> {
		static LongDouble_t Exec(TFormLeafInfo linfo, TLeaf leaf, Int_t instan
		ce) { return linfo->GetValueLongDouble(leaf, instance); }
	};	};

	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	//	//
	// TFormLeafInfoDirect is a small helper class to implement reading a data	// TFormLeafInfoDirect is a small helper class to implement reading a data
	// member on an object stored in a TTree.	// member on an object stored in a TTree.

	class TFormLeafInfoDirect : public TFormLeafInfo {	class TFormLeafInfoDirect : public TFormLeafInfo {
	public:	public:
	TFormLeafInfoDirect(TBranchElement * from);	TFormLeafInfoDirect(TBranchElement * from);
	// The implicit default constructor's implementation is correct.	// The implicit default constructor's implementation is correct.

	virtual TFormLeafInfo* DeepCopy() const;	virtual TFormLeafInfo* DeepCopy() const;


	virtual Double_t ReadValue(char * /where/, Int_t /instance/= 0);	DECLARE_GETVAL;
	virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0);
	virtual void GetLocalValuePointer(TLeaf leaf, Int_t instance = 0);	virtual void GetLocalValuePointer(TLeaf leaf, Int_t instance = 0);
	virtual void GetLocalValuePointer(char thisobj, Int_t instance = 0 );	virtual void GetLocalValuePointer(char thisobj, Int_t instance = 0 );


		virtual Double_t ReadValue(char * /where/, Int_t /instance/= 0);
		virtual Long64_t ReadValueLong64(char *where, Int_t i= 0) { return Read
		Value(where, i); }
		virtual LongDouble_t ReadValueLongDouble(char *where, Int_t i= 0) { ret
		urn ReadValue(where, i); }

	};	};

	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	//	//
	// TFormLeafInfoNumerical is a small helper class to implement reading a	// TFormLeafInfoNumerical is a small helper class to implement reading a
	// numerical value inside a collection	// numerical value inside a collection

	class TFormLeafInfoNumerical : public TFormLeafInfo {	class TFormLeafInfoNumerical : public TFormLeafInfo {
	EDataType fKind;	EDataType fKind;
	Bool_t fIsBool;	Bool_t fIsBool;

	skipping to change at line 163	skipping to change at line 223
	TFormLeafInfoCollectionObject(TClass* classptr = 0, Bool_t fTop = kTRUE) ;	TFormLeafInfoCollectionObject(TClass* classptr = 0, Bool_t fTop = kTRUE) ;
	TFormLeafInfoCollectionObject(const TFormLeafInfoCollectionObject &orig) ;	TFormLeafInfoCollectionObject(const TFormLeafInfoCollectionObject &orig) ;

	void Swap(TFormLeafInfoCollectionObject &other);	void Swap(TFormLeafInfoCollectionObject &other);
	TFormLeafInfoCollectionObject &operator=(const TFormLeafInfoCollectionOb ject &orig);	TFormLeafInfoCollectionObject &operator=(const TFormLeafInfoCollectionOb ject &orig);

	virtual TFormLeafInfo* DeepCopy() const {	virtual TFormLeafInfo* DeepCopy() const {
	return new TFormLeafInfoCollectionObject(*this);	return new TFormLeafInfoCollectionObject(*this);
	}	}


		DECLARE_GETVAL;
	virtual Int_t GetCounterValue(TLeaf* leaf);	virtual Int_t GetCounterValue(TLeaf* leaf);
	virtual Double_t ReadValue(char *where, Int_t instance = 0);	virtual Double_t ReadValue(char *where, Int_t instance = 0);

	virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0);	virtual Long64_t ReadValueLong64(char *where, Int_t i= 0) { return Read
		Value(where, i); }
		virtual LongDouble_t ReadValueLongDouble(char *where, Int_t i= 0) { ret
		urn ReadValue(where, i); }
	virtual void GetValuePointer(TLeaf leaf, Int_t instance = 0);	virtual void GetValuePointer(TLeaf leaf, Int_t instance = 0);
	virtual void GetValuePointer(char thisobj, Int_t instance = 0);	virtual void GetValuePointer(char thisobj, Int_t instance = 0);
	virtual void GetLocalValuePointer(TLeaf leaf, Int_t instance = 0);	virtual void GetLocalValuePointer(TLeaf leaf, Int_t instance = 0);
	virtual void GetLocalValuePointer(char thisobj, Int_t instance = 0);	virtual void GetLocalValuePointer(char thisobj, Int_t instance = 0);
	};	};

	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	//	//
	// TFormLeafInfoClones is a small helper class to implement reading a data	// TFormLeafInfoClones is a small helper class to implement reading a data
	// member on a TClonesArray object stored in a TTree.	// member on a TClonesArray object stored in a TTree.

	skipping to change at line 194	skipping to change at line 256
	Bool_t top = kFALSE);	Bool_t top = kFALSE);
	TFormLeafInfoClones(const TFormLeafInfoClones &orig);	TFormLeafInfoClones(const TFormLeafInfoClones &orig);

	void Swap(TFormLeafInfoClones &other);	void Swap(TFormLeafInfoClones &other);
	TFormLeafInfoClones &operator=(const TFormLeafInfoClones &orig);	TFormLeafInfoClones &operator=(const TFormLeafInfoClones &orig);

	virtual TFormLeafInfo* DeepCopy() const {	virtual TFormLeafInfo* DeepCopy() const {
	return new TFormLeafInfoClones(*this);	return new TFormLeafInfoClones(*this);
	}	}


		DECLARE_GETVAL;
		DECLARE_READVAL;
	virtual Int_t GetCounterValue(TLeaf* leaf);	virtual Int_t GetCounterValue(TLeaf* leaf);
	virtual Int_t ReadCounterValue(char *where);	virtual Int_t ReadCounterValue(char *where);

	virtual Double_t ReadValue(char *where, Int_t instance = 0);
	virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0);
	virtual void GetValuePointer(TLeaf leaf, Int_t instance = 0);	virtual void GetValuePointer(TLeaf leaf, Int_t instance = 0);
	virtual void GetValuePointer(char thisobj, Int_t instance = 0);	virtual void GetValuePointer(char thisobj, Int_t instance = 0);
	virtual void GetLocalValuePointer(TLeaf leaf, Int_t instance = 0);	virtual void GetLocalValuePointer(TLeaf leaf, Int_t instance = 0);
	virtual void GetLocalValuePointer(char thisobj, Int_t instance = 0);	virtual void GetLocalValuePointer(char thisobj, Int_t instance = 0);
	};	};

	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	//	//
	// TFormLeafInfoCollection is a small helper class to implement reading a d ata member	// TFormLeafInfoCollection is a small helper class to implement reading a d ata member
	// on a generic collection object stored in a TTree.	// on a generic collection object stored in a TTree.

	skipping to change at line 240	skipping to change at line 302

	~TFormLeafInfoCollection();	~TFormLeafInfoCollection();

	void Swap(TFormLeafInfoCollection &other);	void Swap(TFormLeafInfoCollection &other);
	TFormLeafInfoCollection &operator=(const TFormLeafInfoCollection &orig);	TFormLeafInfoCollection &operator=(const TFormLeafInfoCollection &orig);

	virtual TFormLeafInfo* DeepCopy() const;	virtual TFormLeafInfo* DeepCopy() const;

	virtual Bool_t Update();	virtual Bool_t Update();


		DECLARE_GETVAL;
		DECLARE_READVAL;
	virtual Int_t GetCounterValue(TLeaf* leaf);	virtual Int_t GetCounterValue(TLeaf* leaf);
	virtual Int_t ReadCounterValue(char* where);	virtual Int_t ReadCounterValue(char* where);
	virtual Int_t GetCounterValue(TLeaf* leaf, Int_t instance);	virtual Int_t GetCounterValue(TLeaf* leaf, Int_t instance);
	virtual Bool_t HasCounter() const;	virtual Bool_t HasCounter() const;

	virtual Double_t ReadValue(char *where, Int_t instance = 0);
	virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0);
	virtual void GetValuePointer(TLeaf leaf, Int_t instance = 0);	virtual void GetValuePointer(TLeaf leaf, Int_t instance = 0);
	virtual void GetValuePointer(char thisobj, Int_t instance = 0);	virtual void GetValuePointer(char thisobj, Int_t instance = 0);
	virtual void GetLocalValuePointer(TLeaf leaf, Int_t instance = 0);	virtual void GetLocalValuePointer(TLeaf leaf, Int_t instance = 0);
	virtual void GetLocalValuePointer(char thisobj, Int_t instance = 0);	virtual void GetLocalValuePointer(char thisobj, Int_t instance = 0);
	};	};

	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	//	//
	// TFormLeafInfoCollectionSize is used to return the size of a collection	// TFormLeafInfoCollectionSize is used to return the size of a collection
	//	//

	skipping to change at line 280	skipping to change at line 342

	virtual TFormLeafInfo* DeepCopy() const;	virtual TFormLeafInfo* DeepCopy() const;

	virtual Bool_t Update();	virtual Bool_t Update();

	virtual void GetValuePointer(TLeaf leaf, Int_t instance = 0);	virtual void GetValuePointer(TLeaf leaf, Int_t instance = 0);
	virtual void GetValuePointer(char from, Int_t instance = 0);	virtual void GetValuePointer(char from, Int_t instance = 0);
	virtual void GetLocalValuePointer(TLeaf leaf, Int_t instance = 0);	virtual void GetLocalValuePointer(TLeaf leaf, Int_t instance = 0);
	virtual void GetLocalValuePointer( char from, Int_t instance = 0);	virtual void GetLocalValuePointer( char from, Int_t instance = 0);
	virtual Double_t ReadValue(char *where, Int_t instance = 0);	virtual Double_t ReadValue(char *where, Int_t instance = 0);

		virtual Long64_t ReadValueLong64(char *where, Int_t i= 0) { return Read
		Value(where, i); }
		virtual LongDouble_t ReadValueLongDouble(char *where, Int_t i= 0) { ret
		urn ReadValue(where, i); }
	};	};

	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	//	//
	// TFormLeafInfoPointer is a small helper class to implement reading a data	// TFormLeafInfoPointer is a small helper class to implement reading a data
	// member by following a pointer inside a branch of TTree.	// member by following a pointer inside a branch of TTree.

	class TFormLeafInfoPointer : public TFormLeafInfo {	class TFormLeafInfoPointer : public TFormLeafInfo {
	public:	public:
	TFormLeafInfoPointer(TClass* classptr = 0, Long_t offset = 0,	TFormLeafInfoPointer(TClass* classptr = 0, Long_t offset = 0,
	TStreamerElement* element = 0);	TStreamerElement* element = 0);
	// The default copy constructor is the right implementation.	// The default copy constructor is the right implementation.

	virtual TFormLeafInfo* DeepCopy() const;	virtual TFormLeafInfo* DeepCopy() const;


	virtual Double_t ReadValue(char *where, Int_t instance = 0);	DECLARE_GETVAL;
	virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0);	DECLARE_READVAL;
	};	};

	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	//	//
	// TFormLeafInfoMethod is a small helper class to implement executing a met hod	// TFormLeafInfoMethod is a small helper class to implement executing a met hod
	// of an object stored in a TTree	// of an object stored in a TTree

	class TFormLeafInfoMethod : public TFormLeafInfo {	class TFormLeafInfoMethod : public TFormLeafInfo {

	TMethodCall *fMethod;	TMethodCall *fMethod;

	skipping to change at line 326	skipping to change at line 390

	TFormLeafInfoMethod(TClass* classptr = 0, TMethodCall *method = 0);	TFormLeafInfoMethod(TClass* classptr = 0, TMethodCall *method = 0);
	TFormLeafInfoMethod(const TFormLeafInfoMethod& orig);	TFormLeafInfoMethod(const TFormLeafInfoMethod& orig);
	~TFormLeafInfoMethod();	~TFormLeafInfoMethod();

	void Swap(TFormLeafInfoMethod &other);	void Swap(TFormLeafInfoMethod &other);
	TFormLeafInfoMethod &operator=(const TFormLeafInfoMethod &orig);	TFormLeafInfoMethod &operator=(const TFormLeafInfoMethod &orig);

	virtual TFormLeafInfo* DeepCopy() const;	virtual TFormLeafInfo* DeepCopy() const;


		DECLARE_READVAL;
	virtual TClass* GetClass() const;	virtual TClass* GetClass() const;
	virtual void GetLocalValuePointer( TLeaf from, Int_t instance = 0);	virtual void GetLocalValuePointer( TLeaf from, Int_t instance = 0);
	virtual void GetLocalValuePointer(char from, Int_t instance = 0);	virtual void GetLocalValuePointer(char from, Int_t instance = 0);
	virtual Bool_t IsInteger() const;	virtual Bool_t IsInteger() const;
	virtual Bool_t IsString() const;	virtual Bool_t IsString() const;

	virtual Double_t ReadValue(char *where, Int_t instance = 0);
	virtual Bool_t Update();	virtual Bool_t Update();
	};	};

	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	//	//
	// TFormLeafInfoMultiVarDim is a small helper class to implement reading a	// TFormLeafInfoMultiVarDim is a small helper class to implement reading a
	// data member on a variable size array inside a TClonesArray object stored in	// data member on a variable size array inside a TClonesArray object stored in
	// a TTree. This is the version used when the data member is inside a	// a TTree. This is the version used when the data member is inside a
	// non-split object.	// non-split object.


	skipping to change at line 382	skipping to change at line 446
	//}	//}

	virtual void LoadSizes(TBranch* branch);	virtual void LoadSizes(TBranch* branch);
	virtual Int_t GetPrimaryIndex();	virtual Int_t GetPrimaryIndex();
	virtual void SetPrimaryIndex(Int_t index);	virtual void SetPrimaryIndex(Int_t index);
	virtual void SetSecondaryIndex(Int_t index);	virtual void SetSecondaryIndex(Int_t index);
	virtual void SetSize(Int_t index, Int_t val);	virtual void SetSize(Int_t index, Int_t val);
	virtual Int_t GetSize(Int_t index);	virtual Int_t GetSize(Int_t index);
	virtual Int_t GetSumOfSizes();	virtual Int_t GetSumOfSizes();
	virtual Double_t GetValue(TLeaf * /leaf/, Int_t /instance/ = 0);	virtual Double_t GetValue(TLeaf * /leaf/, Int_t /instance/ = 0);

		virtual Long64_t GetValueLong64(TLeaf *leaf, Int_t i= 0) { return GetVa
		lue(leaf, i); }
		virtual LongDouble_t GetValueLongDouble(TLeaf *leaf, Int_t i= 0) { retu
		rn GetValue(leaf, i); }
	virtual Int_t GetVarDim();	virtual Int_t GetVarDim();
	virtual Int_t GetVirtVarDim();	virtual Int_t GetVirtVarDim();
	virtual Bool_t Update();	virtual Bool_t Update();
	virtual void UpdateSizes(TArrayI *garr);	virtual void UpdateSizes(TArrayI *garr);
	};	};

	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	//	//
	// TFormLeafInfoMultiVarDimDirect is a small helper class to implement read ing	// TFormLeafInfoMultiVarDimDirect is a small helper class to implement read ing
	// a data member on a variable size array inside a TClonesArray object stor ed	// a data member on a variable size array inside a TClonesArray object stor ed
	// in a TTree. This is the version used for split access	// in a TTree. This is the version used for split access

	class TFormLeafInfoMultiVarDimDirect : public TFormLeafInfoMultiVarDim {	class TFormLeafInfoMultiVarDimDirect : public TFormLeafInfoMultiVarDim {
	public:	public:
	// The default constructor are the correct implementation.	// The default constructor are the correct implementation.

	virtual TFormLeafInfo* DeepCopy() const;	virtual TFormLeafInfo* DeepCopy() const;


	virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0);	DECLARE_GETVAL;
	virtual Double_t ReadValue(char * /where/, Int_t /instance/ = 0);	virtual Double_t ReadValue(char * /where/, Int_t /instance/ = 0);

		virtual Long64_t ReadValueLong64(char *where, Int_t i= 0) { return Read
		Value(where, i); }
		virtual LongDouble_t ReadValueLongDouble(char *where, Int_t i= 0) { ret
		urn ReadValue(where, i); }
	};	};

	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	//	//
	// TFormLeafInfoMultiVarDimCollection is a small helper class to implement reading	// TFormLeafInfoMultiVarDimCollection is a small helper class to implement reading
	// a data member which is a collection inside a TClonesArray or collection object	// a data member which is a collection inside a TClonesArray or collection object
	// stored in a TTree. This is the version used for split access	// stored in a TTree. This is the version used for split access
	//	//
	class TFormLeafInfoMultiVarDimCollection : public TFormLeafInfoMultiVarDim {	class TFormLeafInfoMultiVarDimCollection : public TFormLeafInfoMultiVarDim {
	public:	public:

	skipping to change at line 423	skipping to change at line 491
	TClass* elementclassptr, TFormLeafInfo *parent);	TClass* elementclassptr, TFormLeafInfo *parent);
	TFormLeafInfoMultiVarDimCollection(TClass* classptr, Long_t offset,	TFormLeafInfoMultiVarDimCollection(TClass* classptr, Long_t offset,
	TStreamerElement* element, TFormLeafInfo* parent);	TStreamerElement* element, TFormLeafInfo* parent);
	// The default copy constructor is the right implementation.	// The default copy constructor is the right implementation.

	virtual TFormLeafInfo* DeepCopy() const;	virtual TFormLeafInfo* DeepCopy() const;

	virtual Int_t GetArrayLength() { return 0; }	virtual Int_t GetArrayLength() { return 0; }
	virtual void LoadSizes(TBranch* branch);	virtual void LoadSizes(TBranch* branch);
	virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0);	virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0);

	virtual Double_t ReadValue(char * /where/, Int_t /instance/ = 0);	virtual Long64_t GetValueLong64(TLeaf *leaf, Int_t i= 0) { return GetVa
		lue(leaf, i); }
		virtual LongDouble_t GetValueLongDouble(TLeaf *leaf, Int_t i= 0) { retu
		rn GetValue(leaf, i); }
		DECLARE_READVAL;
	};	};

	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	//	//
	// TFormLeafInfoMultiVarDimClones is a small helper class to implement read ing	// TFormLeafInfoMultiVarDimClones is a small helper class to implement read ing
	// a data member which is a TClonesArray inside a TClonesArray or collectio n object	// a data member which is a TClonesArray inside a TClonesArray or collectio n object
	// stored in a TTree. This is the version used for split access	// stored in a TTree. This is the version used for split access
	//	//
	class TFormLeafInfoMultiVarDimClones : public TFormLeafInfoMultiVarDim {	class TFormLeafInfoMultiVarDimClones : public TFormLeafInfoMultiVarDim {
	public:	public:

	skipping to change at line 445	skipping to change at line 515
	TClass* elementclassptr, TFormLeafInfo *parent);	TClass* elementclassptr, TFormLeafInfo *parent);
	TFormLeafInfoMultiVarDimClones(TClass* classptr, Long_t offset,	TFormLeafInfoMultiVarDimClones(TClass* classptr, Long_t offset,
	TStreamerElement* element, TFormLeafInfo* parent);	TStreamerElement* element, TFormLeafInfo* parent);
	// The default copy constructor is the right implementation.	// The default copy constructor is the right implementation.

	virtual TFormLeafInfo* DeepCopy() const;	virtual TFormLeafInfo* DeepCopy() const;

	virtual Int_t GetArrayLength() { return 0; }	virtual Int_t GetArrayLength() { return 0; }
	virtual void LoadSizes(TBranch* branch);	virtual void LoadSizes(TBranch* branch);
	virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0);	virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0);

	virtual Double_t ReadValue(char * /where/, Int_t /instance/ = 0);	virtual Long64_t GetValueLong64(TLeaf *leaf, Int_t i= 0) { return GetVa
		lue(leaf, i); }
		virtual LongDouble_t GetValueLongDouble(TLeaf *leaf, Int_t i= 0) { retu
		rn GetValue(leaf, i); }
		DECLARE_READVAL;
	};	};

	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	//	//
	// TFormLeafInfoCast is a small helper class to implement casting an object to	// TFormLeafInfoCast is a small helper class to implement casting an object to
	// a different type (equivalent to dynamic_cast)	// a different type (equivalent to dynamic_cast)

	class TFormLeafInfoCast : public TFormLeafInfo {	class TFormLeafInfoCast : public TFormLeafInfo {
	public:	public:
	TClass *fCasted; //! Pointer to the class we are trying to case to	TClass *fCasted; //! Pointer to the class we are trying to case to

	skipping to change at line 469	skipping to change at line 541

	TFormLeafInfoCast(TClass* classptr = 0, TClass* casted = 0);	TFormLeafInfoCast(TClass* classptr = 0, TClass* casted = 0);
	TFormLeafInfoCast(const TFormLeafInfoCast& orig);	TFormLeafInfoCast(const TFormLeafInfoCast& orig);
	virtual ~TFormLeafInfoCast();	virtual ~TFormLeafInfoCast();

	void Swap(TFormLeafInfoCast &other);	void Swap(TFormLeafInfoCast &other);
	TFormLeafInfoCast &operator=(const TFormLeafInfoCast &orig);	TFormLeafInfoCast &operator=(const TFormLeafInfoCast &orig);

	virtual TFormLeafInfo* DeepCopy() const;	virtual TFormLeafInfo* DeepCopy() const;


		DECLARE_READVAL;
	// Currently only implemented in TFormLeafInfoCast	// Currently only implemented in TFormLeafInfoCast
	virtual Int_t GetNdata();	virtual Int_t GetNdata();

	virtual Double_t ReadValue(char *where, Int_t instance = 0);
	virtual Bool_t Update();	virtual Bool_t Update();
	};	};

	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	//	//
	// TFormLeafTTree is a small helper class to implement reading	// TFormLeafTTree is a small helper class to implement reading
	// from the containing TTree object itself.	// from the containing TTree object itself.

	class TFormLeafInfoTTree : public TFormLeafInfo {	class TFormLeafInfoTTree : public TFormLeafInfo {
	TTree *fTree;	TTree *fTree;

	skipping to change at line 497	skipping to change at line 569
	TFormLeafInfoTTree(const TFormLeafInfoTTree& orig);	TFormLeafInfoTTree(const TFormLeafInfoTTree& orig);

	void Swap(TFormLeafInfoTTree &other);	void Swap(TFormLeafInfoTTree &other);
	TFormLeafInfoTTree &operator=(const TFormLeafInfoTTree &orig);	TFormLeafInfoTTree &operator=(const TFormLeafInfoTTree &orig);

	virtual TFormLeafInfo* DeepCopy() const;	virtual TFormLeafInfo* DeepCopy() const;

	using TFormLeafInfo::GetLocalValuePointer;	using TFormLeafInfo::GetLocalValuePointer;
	using TFormLeafInfo::GetValue;	using TFormLeafInfo::GetValue;


		DECLARE_GETVAL;
		DECLARE_READVAL;
	virtual void GetLocalValuePointer(TLeaf leaf, Int_t instance = 0);	virtual void GetLocalValuePointer(TLeaf leaf, Int_t instance = 0);

	virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0);
	virtual Double_t ReadValue(char *thisobj, Int_t instance);
	virtual Bool_t Update();	virtual Bool_t Update();
	};	};

	#endif /* ROOT_TFormLeafInfo */	#endif /* ROOT_TFormLeafInfo */

End of changes. 25 change blocks.
	20 lines changed or deleted	128 lines changed or added

	TGeoPatternFinder.h	TGeoPatternFinder.h

	skipping to change at line 482	skipping to change at line 482
	TGeoPatternSphTheta(TGeoVolume *vol, Int_t ndivisions, Double_t step);	TGeoPatternSphTheta(TGeoVolume *vol, Int_t ndivisions, Double_t step);
	TGeoPatternSphTheta(TGeoVolume *vol, Int_t ndivisions, Double_t start, D ouble_t end);	TGeoPatternSphTheta(TGeoVolume *vol, Int_t ndivisions, Double_t start, D ouble_t end);
	TGeoPatternSphTheta(const TGeoPatternSphTheta &pf);	TGeoPatternSphTheta(const TGeoPatternSphTheta &pf);
	TGeoPatternSphTheta& operator=(const TGeoPatternSphTheta&);	TGeoPatternSphTheta& operator=(const TGeoPatternSphTheta&);
	// destructor	// destructor
	virtual ~TGeoPatternSphTheta();	virtual ~TGeoPatternSphTheta();
	// methods	// methods
	virtual TGeoMatrix* CreateMatrix() const;	virtual TGeoMatrix* CreateMatrix() const;
	virtual void cd(Int_t idiv);	virtual void cd(Int_t idiv);
	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);

	virtual Int_t GetDivAxis() {return 2;}	virtual Int_t GetDivAxis() {return 3;}
	virtual	virtual
	TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);	TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;	virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;

	ClassDef(TGeoPatternSphTheta, 1) // spherical theta divisio n pattern	ClassDef(TGeoPatternSphTheta, 1) // spherical theta divisio n pattern
	};	};

	/////////////////////////////////////////////////////////////////////////// /	/////////////////////////////////////////////////////////////////////////// /
	// / /	// / /
	// TGeoPatternSphPhi - a spherical phi divison pattern / /	// TGeoPatternSphPhi - a spherical phi divison pattern / /
	// / /	// / /
	/////////////////////////////////////////////////////////////////////////// /	/////////////////////////////////////////////////////////////////////////// /

	class TGeoPatternSphPhi : public TGeoPatternFinder	class TGeoPatternSphPhi : public TGeoPatternFinder
	{	{

		//new_code_start
		private:
		Double_t *fSinCos;
		//new_code_end

	public:	public:

		TGeoPatternSphPhi(const TGeoPatternSphPhi& pfc)
		: TGeoPatternFinder(pfc), fSinCos(pfc.fSinCos) {CreateThreadData(1);}
		TGeoPatternSphPhi& operator=(const TGeoPatternSphPhi& pfc)
		{if(this!=&pfc) {TGeoPatternFinder::operator=(pfc); fSinCos=pfc.fSinCo
		s; CreateThreadData(1);}
		return *this;}

	// constructors	// constructors
	TGeoPatternSphPhi();	TGeoPatternSphPhi();
	TGeoPatternSphPhi(TGeoVolume *vol, Int_t ndivisions);	TGeoPatternSphPhi(TGeoVolume *vol, Int_t ndivisions);
	TGeoPatternSphPhi(TGeoVolume *vol, Int_t ndivisions, Double_t step);	TGeoPatternSphPhi(TGeoVolume *vol, Int_t ndivisions, Double_t step);
	TGeoPatternSphPhi(TGeoVolume *vol, Int_t ndivisions, Double_t start, Dou ble_t end);	TGeoPatternSphPhi(TGeoVolume *vol, Int_t ndivisions, Double_t start, Dou ble_t end);

	TGeoPatternSphPhi(const TGeoPatternSphPhi &pf);
	TGeoPatternSphPhi& operator=(const TGeoPatternSphPhi&);
	// destructor	// destructor
	virtual ~TGeoPatternSphPhi();	virtual ~TGeoPatternSphPhi();
	// methods	// methods
	virtual TGeoMatrix* CreateMatrix() const;	virtual TGeoMatrix* CreateMatrix() const;
	virtual void cd(Int_t idiv);	virtual void cd(Int_t idiv);
	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);

	virtual Int_t GetDivAxis() {return 3;}	virtual Int_t GetDivAxis() {return 2;}
		virtual Bool_t IsOnBoundary(const Double_t *point) const;
	virtual	virtual
	TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);	TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;	virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;

	ClassDef(TGeoPatternSphPhi, 1) // Spherical phi division pa ttern	ClassDef(TGeoPatternSphPhi, 1) // Spherical phi division pa ttern
	};	};

	/////////////////////////////////////////////////////////////////////////// /	/////////////////////////////////////////////////////////////////////////// /
	// / /	// / /

End of changes. 5 change blocks.
	4 lines changed or deleted	15 lines changed or added

	TGraph.h	TGraph.h

	skipping to change at line 76	skipping to change at line 76
	virtual void SwapPoints(Int_t pos1, Int_t pos2);	virtual void SwapPoints(Int_t pos1, Int_t pos2);

	virtual Double_t **Allocate(Int_t newsize);	virtual Double_t **Allocate(Int_t newsize);
	Double_t **AllocateArrays(Int_t Narrays, Int_t arraySize);	Double_t **AllocateArrays(Int_t Narrays, Int_t arraySize);
	virtual Bool_t CopyPoints(Double_t **newarrays, Int_t ibegin, Int_t iend, Int_t obegin);	virtual Bool_t CopyPoints(Double_t **newarrays, Int_t ibegin, Int_t iend, Int_t obegin);
	virtual void CopyAndRelease(Double_t **newarrays, Int_t ibegin, In t_t iend, Int_t obegin);	virtual void CopyAndRelease(Double_t **newarrays, Int_t ibegin, In t_t iend, Int_t obegin);
	Bool_t CtorAllocate();	Bool_t CtorAllocate();
	Double_t **ExpandAndCopy(Int_t size, Int_t iend);	Double_t **ExpandAndCopy(Int_t size, Int_t iend);
	virtual void FillZero(Int_t begin, Int_t end, Bool_t from_ctor = k TRUE);	virtual void FillZero(Int_t begin, Int_t end, Bool_t from_ctor = k TRUE);
	Double_t **ShrinkAndCopy(Int_t size, Int_t iend);	Double_t **ShrinkAndCopy(Int_t size, Int_t iend);

		virtual Bool_t DoMerge(const TGraph * g);

	public:	public:
	// TGraph status bits	// TGraph status bits
	enum {	enum {
	kClipFrame = BIT(10), // clip to the frame boundary	kClipFrame = BIT(10), // clip to the frame boundary
	kNotEditable = BIT(18) // bit set if graph is non editable	kNotEditable = BIT(18) // bit set if graph is non editable
	};	};

	TGraph();	TGraph();
	TGraph(Int_t n);	TGraph(Int_t n);

End of changes. 1 change blocks.
	0 lines changed or deleted	1 lines changed or added

	TGraph2D.h	TGraph2D.h

	skipping to change at line 53	skipping to change at line 53
	class TH2D;	class TH2D;
	class TView;	class TView;
	class TDirectory;	class TDirectory;

	#include "TFitResultPtr.h"	#include "TFitResultPtr.h"

	class TGraph2D : public TNamed, public TAttLine, public TAttFill, public TA ttMarker {	class TGraph2D : public TNamed, public TAttLine, public TAttFill, public TA ttMarker {

	protected:	protected:


	Int_t fNpoints; // Number of points in the data set	Int_t fNpoints; // Number of points in the data set
	Int_t fNpx; // Number of bins along X in fHistogram	Int_t fNpx; // Number of bins along X in fHistogram
	Int_t fNpy; // Number of bins along Y in fHistogram	Int_t fNpy; // Number of bins along Y in fHistogram
	Int_t fMaxIter; // Maximum number of iterations to find Delaun	Int_t fMaxIter; // Maximum number of iterations to find D
	ay t>	elaunay triangles
	Int_t fSize; //!Real size of fX, fY and fZ	Int_t fSize; //!Real size of fX, fY and fZ
	Double_t *fX; //[fNpoints]	Double_t *fX; //[fNpoints]
	Double_t *fY; //[fNpoints] Data set to be plotted	Double_t *fY; //[fNpoints] Data set to be plotted
	Double_t *fZ; //[fNpoints]	Double_t *fZ; //[fNpoints]
	Double_t fMinimum; // Minimum value for plotting along z	Double_t fMinimum; // Minimum value for plotting along z
	Double_t fMaximum; // Maximum value for plotting along z	Double_t fMaximum; // Maximum value for plotting along z
	Double_t fMargin; // Extra space (in %) around interpolated area	Double_t fMargin; // Extra space (in %) around interpolated
	for fHistogram	area for fHistogram
	Double_t fZout; // fHistogram bin height for points lying outs	Double_t fZout; // fHistogram bin height for points lying
	ide the interpolated area	outside the interpolated area
	TList *fFunctions; // Pointer to list of functions (fits and user	TList *fFunctions; // Pointer to list of functions (fits and
	)	user)
	TH2D *fHistogram; //!2D histogram of z values linearly interpola	TH2D *fHistogram; //!2D histogram of z values linearly inte
	ted	rpolated on the triangles
	TDirectory *fDirectory; //!Pointer to directory holding this 2D graph	TDirectory *fDirectory; //!Pointer to directory holding this 2D g
	TVirtualHistPainter *fPainter; //!pointer to histogram painter	raph
		TVirtualHistPainter *fPainter; //!Pointer to histogram painter

	void Build(Int_t n);	void Build(Int_t n);

	private:	private:

	Bool_t fUserHisto; // True when SetHistogram has been called	Bool_t fUserHisto; // True when SetHistogram has been called

	protected:	protected:

	public:	public:

	skipping to change at line 159	skipping to change at line 159
	void SetMaximum(Double_t maximum=-1111); // MENU	void SetMaximum(Double_t maximum=-1111); // MENU
	void SetMinimum(Double_t minimum=-1111); // MENU	void SetMinimum(Double_t minimum=-1111); // MENU
	void SetMaxIter(Int_t n=100000) {fMaxIter = n;} // MEN U	void SetMaxIter(Int_t n=100000) {fMaxIter = n;} // MEN U
	virtual void SetName(const char name); // MENU*	virtual void SetName(const char name); // MENU*
	virtual void SetNameTitle(const char name, const char title);	virtual void SetNameTitle(const char name, const char title);
	void SetNpx(Int_t npx=40); // MENU	void SetNpx(Int_t npx=40); // MENU
	void SetNpy(Int_t npx=40); // MENU	void SetNpy(Int_t npx=40); // MENU
	virtual void SetPoint(Int_t point, Double_t x, Double_t y, Doub le_t z); // MENU	virtual void SetPoint(Int_t point, Double_t x, Double_t y, Doub le_t z); // MENU
	virtual void SetTitle(const char title=""); // MENU*	virtual void SetTitle(const char title=""); // MENU*


	ClassDef(TGraph2D,1) //Set of n x[i],y[i],z[i] points with 3-d graphics including Delaunay triangulation	ClassDef(TGraph2D,1) //Set of n x[n],y[n],z[n] points with 3-d graphics including Delaunay triangulation
	};	};

	#endif	#endif

End of changes. 2 change blocks.
	22 lines changed or deleted	23 lines changed or added

	TGraph2DErrors.h	TGraph2DErrors.h

	skipping to change at line 31	skipping to change at line 31
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TGraph2D	#ifndef ROOT_TGraph2D
	#include "TGraph2D.h"	#include "TGraph2D.h"
	#endif	#endif

	class TGraph2DErrors : public TGraph2D {	class TGraph2DErrors : public TGraph2D {

	private:	private:


	TGraph2DErrors(const TGraph2DErrors&); // Not implemented
	TGraph2DErrors& operator=(const TGraph2DErrors&); // Not implemented

	protected:	protected:
	Double_t *fEX; //[fNpoints] array of X errors	Double_t *fEX; //[fNpoints] array of X errors
	Double_t *fEY; //[fNpoints] array of Y errors	Double_t *fEY; //[fNpoints] array of Y errors
	Double_t *fEZ; //[fNpoints] array of Z errors	Double_t *fEZ; //[fNpoints] array of Z errors

	public:	public:
	TGraph2DErrors();	TGraph2DErrors();
	TGraph2DErrors(Int_t n);	TGraph2DErrors(Int_t n);
	TGraph2DErrors(Int_t n, Double_t x, Double_t y, Double_t *z,	TGraph2DErrors(Int_t n, Double_t x, Double_t y, Double_t *z,
	Double_t ex=0, Double_t ey=0, Double_t ez=0, Option_t option="");	Double_t ex=0, Double_t ey=0, Double_t ez=0, Option_t option="");

		TGraph2DErrors(const TGraph2DErrors&);
		TGraph2DErrors& operator=(const TGraph2DErrors&);
	virtual ~TGraph2DErrors();	virtual ~TGraph2DErrors();
	Double_t GetErrorX(Int_t bin) const;	Double_t GetErrorX(Int_t bin) const;
	Double_t GetErrorY(Int_t bin) const;	Double_t GetErrorY(Int_t bin) const;
	Double_t GetErrorZ(Int_t bin) const;	Double_t GetErrorZ(Int_t bin) const;
	Double_t *GetEX() const {return fEX;}	Double_t *GetEX() const {return fEX;}
	Double_t *GetEY() const {return fEY;}	Double_t *GetEY() const {return fEY;}
	Double_t *GetEZ() const {return fEZ;}	Double_t *GetEZ() const {return fEZ;}
	Double_t GetXmaxE() const;	Double_t GetXmaxE() const;
	Double_t GetXminE() const;	Double_t GetXminE() const;
	Double_t GetYmaxE() const;	Double_t GetYmaxE() const;

End of changes. 2 change blocks.
	3 lines changed or deleted	2 lines changed or added

	TGraphAsymmErrors.h	TGraphAsymmErrors.h

	skipping to change at line 45	skipping to change at line 45
	virtual void SwapPoints(Int_t pos1, Int_t pos2);	virtual void SwapPoints(Int_t pos1, Int_t pos2);

	virtual Double_t** Allocate(Int_t size);	virtual Double_t** Allocate(Int_t size);
	virtual void CopyAndRelease(Double_t **newarrays,	virtual void CopyAndRelease(Double_t **newarrays,
	Int_t ibegin, Int_t iend, Int_t obegin );	Int_t ibegin, Int_t iend, Int_t obegin );
	virtual Bool_t CopyPoints(Double_t **arrays, Int_t ibegin, Int_t ien d,	virtual Bool_t CopyPoints(Double_t **arrays, Int_t ibegin, Int_t ien d,
	Int_t obegin);	Int_t obegin);
	Bool_t CtorAllocate();	Bool_t CtorAllocate();
	virtual void FillZero(Int_t begin, Int_t end,	virtual void FillZero(Int_t begin, Int_t end,
	Bool_t from_ctor = kTRUE);	Bool_t from_ctor = kTRUE);

		virtual Bool_t DoMerge(const TGraph * g);

	public:	public:
	TGraphAsymmErrors();	TGraphAsymmErrors();
	TGraphAsymmErrors(Int_t n);	TGraphAsymmErrors(Int_t n);
	TGraphAsymmErrors(Int_t n, const Float_t x, const Float_t y, const Flo at_t exl=0, const Float_t exh=0, const Float_t eyl=0, const Float_t eyh =0);	TGraphAsymmErrors(Int_t n, const Float_t x, const Float_t y, const Flo at_t exl=0, const Float_t exh=0, const Float_t eyl=0, const Float_t eyh =0);
	TGraphAsymmErrors(Int_t n, const Double_t x, const Double_t y, const D ouble_t exl=0, const Double_t exh=0, const Double_t eyl=0, const Double_ t eyh=0);	TGraphAsymmErrors(Int_t n, const Double_t x, const Double_t y, const D ouble_t exl=0, const Double_t exh=0, const Double_t eyl=0, const Double_ t eyh=0);
	TGraphAsymmErrors(const TVectorF &vx, const TVectorF &vy, const TVectorF &vexl, const TVectorF &vexh, const TVectorF &veyl, const TVectorF &veyh);	TGraphAsymmErrors(const TVectorF &vx, const TVectorF &vy, const TVectorF &vexl, const TVectorF &vexh, const TVectorF &veyl, const TVectorF &veyh);
	TGraphAsymmErrors(const TVectorD &vx, const TVectorD &vy, const TVectorD &vexl, const TVectorD &vexh, const TVectorD &veyl, const TVectorD &veyh);	TGraphAsymmErrors(const TVectorD &vx, const TVectorD &vy, const TVectorD &vexl, const TVectorD &vexh, const TVectorD &veyl, const TVectorD &veyh);
	TGraphAsymmErrors(const TGraphAsymmErrors &gr);	TGraphAsymmErrors(const TGraphAsymmErrors &gr);
	TGraphAsymmErrors& operator=(const TGraphAsymmErrors &gr);	TGraphAsymmErrors& operator=(const TGraphAsymmErrors &gr);

End of changes. 1 change blocks.
	0 lines changed or deleted	1 lines changed or added

	TGraphBentErrors.h	TGraphBentErrors.h

	skipping to change at line 50	skipping to change at line 50
	virtual void SwapPoints(Int_t pos1, Int_t pos2);	virtual void SwapPoints(Int_t pos1, Int_t pos2);

	virtual Double_t** Allocate(Int_t size);	virtual Double_t** Allocate(Int_t size);
	virtual void CopyAndRelease(Double_t **newarrays,	virtual void CopyAndRelease(Double_t **newarrays,
	Int_t ibegin, Int_t iend, Int_t obegin );	Int_t ibegin, Int_t iend, Int_t obegin );
	virtual Bool_t CopyPoints(Double_t **arrays, Int_t ibegin, Int_t ien d,	virtual Bool_t CopyPoints(Double_t **arrays, Int_t ibegin, Int_t ien d,
	Int_t obegin);	Int_t obegin);
	Bool_t CtorAllocate();	Bool_t CtorAllocate();
	virtual void FillZero(Int_t begin, Int_t end,	virtual void FillZero(Int_t begin, Int_t end,
	Bool_t from_ctor = kTRUE);	Bool_t from_ctor = kTRUE);

		virtual Bool_t DoMerge(const TGraph * g);

	public:	public:
	TGraphBentErrors();	TGraphBentErrors();
	TGraphBentErrors(Int_t n);	TGraphBentErrors(Int_t n);
	TGraphBentErrors(Int_t n,	TGraphBentErrors(Int_t n,
	const Float_t x, const Float_t y,	const Float_t x, const Float_t y,
	const Float_t exl=0, const Float_t exh=0,	const Float_t exl=0, const Float_t exh=0,
	const Float_t eyl=0, const Float_t eyh=0,	const Float_t eyl=0, const Float_t eyh=0,
	const Float_t exld=0, const Float_t exhd=0,	const Float_t exld=0, const Float_t exhd=0,
	const Float_t eyld=0, const Float_t eyhd=0);	const Float_t eyld=0, const Float_t eyhd=0);

End of changes. 1 change blocks.
	0 lines changed or deleted	1 lines changed or added

	TGraphErrors.h	TGraphErrors.h

	skipping to change at line 43	skipping to change at line 43
	virtual void SwapPoints(Int_t pos1, Int_t pos2);	virtual void SwapPoints(Int_t pos1, Int_t pos2);

	virtual Double_t** Allocate(Int_t size);	virtual Double_t** Allocate(Int_t size);
	virtual void CopyAndRelease(Double_t **newarrays,	virtual void CopyAndRelease(Double_t **newarrays,
	Int_t ibegin, Int_t iend, Int_t obegin );	Int_t ibegin, Int_t iend, Int_t obegin );
	virtual Bool_t CopyPoints(Double_t **arrays, Int_t ibegin, Int_t ien d,	virtual Bool_t CopyPoints(Double_t **arrays, Int_t ibegin, Int_t ien d,
	Int_t obegin);	Int_t obegin);
	Bool_t CtorAllocate();	Bool_t CtorAllocate();
	virtual void FillZero(Int_t begin, Int_t end,	virtual void FillZero(Int_t begin, Int_t end,
	Bool_t from_ctor = kTRUE);	Bool_t from_ctor = kTRUE);

		virtual Bool_t DoMerge(const TGraph * g);

	public:	public:
	TGraphErrors();	TGraphErrors();
	TGraphErrors(Int_t n);	TGraphErrors(Int_t n);
	TGraphErrors(Int_t n, const Float_t x, const Float_t y, const Float_t ex=0, const Float_t ey=0);	TGraphErrors(Int_t n, const Float_t x, const Float_t y, const Float_t ex=0, const Float_t ey=0);
	TGraphErrors(Int_t n, const Double_t x, const Double_t y, const Double _t ex=0, const Double_t ey=0);	TGraphErrors(Int_t n, const Double_t x, const Double_t y, const Double _t ex=0, const Double_t ey=0);
	TGraphErrors(const TVectorF &vx, const TVectorF &vy, const TVectorF &vex , const TVectorF &vey);	TGraphErrors(const TVectorF &vx, const TVectorF &vy, const TVectorF &vex , const TVectorF &vey);
	TGraphErrors(const TVectorD &vx, const TVectorD &vy, const TVectorD &vex , const TVectorD &vey);	TGraphErrors(const TVectorD &vx, const TVectorD &vy, const TVectorD &vex , const TVectorD &vey);
	TGraphErrors(const TGraphErrors &gr);	TGraphErrors(const TGraphErrors &gr);
	TGraphErrors& operator=(const TGraphErrors &gr);	TGraphErrors& operator=(const TGraphErrors &gr);

End of changes. 1 change blocks.
	0 lines changed or deleted	1 lines changed or added

	THtml.h	THtml.h

	skipping to change at line 174	skipping to change at line 174
	fullname += fName;	fullname += fName;
	}	}

	ClassDef(TFileSysRoot, 0); // an root directory of the local file sys tem	ClassDef(TFileSysRoot, 0); // an root directory of the local file sys tem
	};	};

	//______________________________________________________________	//______________________________________________________________
	// Utility class representing a directory	// Utility class representing a directory
	class TFileSysDB: public TFileSysDir {	class TFileSysDB: public TFileSysDir {
	public:	public:

	TFileSysDB(const char* path, const char* ignore, Int_t maxdirlevel):	TFileSysDB(const char* path, const char* ignr, Int_t maxdirlevel):
	TFileSysDir(path, 0), fEntries(1009, 5), fIgnorePath(ignore), fMax	TFileSysDir(path, 0), fEntries(1009, 5), fIgnorePath(ignr), fMaxLe
	Level(maxdirlevel)	vel(maxdirlevel)
	{ Fill(); }	{ Fill(); }

	TExMap& GetMapIno() { return fMapIno; }	TExMap& GetMapIno() { return fMapIno; }
	THashTable& GetEntries() { return fEntries; }	THashTable& GetEntries() { return fEntries; }
	const TString& GetIgnore() const { return fIgnorePath; }	const TString& GetIgnore() const { return fIgnorePath; }
	Int_t GetMaxLevel() const { return fMaxLevel; }	Int_t GetMaxLevel() const { return fMaxLevel; }

	protected:	protected:
	void Fill();	void Fill();


End of changes. 1 change blocks.
	3 lines changed or deleted	3 lines changed or added

	TLeaf.h	TLeaf.h

	skipping to change at line 51	skipping to change at line 51
	Int_t fLenType; // Number of bytes for this data type	Int_t fLenType; // Number of bytes for this data type
	Int_t fOffset; // Offset in ClonesArray object (if one)	Int_t fOffset; // Offset in ClonesArray object (if one)
	Bool_t fIsRange; // (=kTRUE if leaf has a range, kFALSE ot herwise)	Bool_t fIsRange; // (=kTRUE if leaf has a range, kFALSE ot herwise)
	Bool_t fIsUnsigned; // (=kTRUE if unsigned, kFALSE otherwise)	Bool_t fIsUnsigned; // (=kTRUE if unsigned, kFALSE otherwise)
	TLeaf *fLeafCount; // Pointer to Leaf count if variable leng th (we do not own the counter)	TLeaf *fLeafCount; // Pointer to Leaf count if variable leng th (we do not own the counter)
	TBranch *fBranch; //! Pointer to supporting branch (we do no t own the branch)	TBranch *fBranch; //! Pointer to supporting branch (we do no t own the branch)

	TLeaf(const TLeaf&);	TLeaf(const TLeaf&);
	TLeaf& operator=(const TLeaf&);	TLeaf& operator=(const TLeaf&);


		template <typename T> struct GetValueHelper {
		static T Exec(const TLeaf *leaf, Int_t i = 0) { return leaf->GetValue(i
		); }
		};

	public:	public:
	enum {	enum {
	kIndirectAddress = BIT(11), // Data member is a pointer to an array o f basic types.	kIndirectAddress = BIT(11), // Data member is a pointer to an array o f basic types.
	kNewValue = BIT(12) // Set if we own the value buffer and so must delete it ourselves.	kNewValue = BIT(12) // Set if we own the value buffer and so must delete it ourselves.
	};	};

	TLeaf();	TLeaf();
	TLeaf(TBranch parent, const char name, const char* type);	TLeaf(TBranch parent, const char name, const char* type);
	virtual ~TLeaf();	virtual ~TLeaf();


	skipping to change at line 76	skipping to change at line 80
	virtual TLeaf *GetLeafCounter(Int_t& countval) const;	virtual TLeaf *GetLeafCounter(Int_t& countval) const;
	virtual Int_t GetLen() const;	virtual Int_t GetLen() const;
	virtual Int_t GetLenStatic() const { return fLen; }	virtual Int_t GetLenStatic() const { return fLen; }
	virtual Int_t GetLenType() const { return fLenType; }	virtual Int_t GetLenType() const { return fLenType; }
	virtual Int_t GetMaximum() const { return 0; }	virtual Int_t GetMaximum() const { return 0; }
	virtual Int_t GetMinimum() const { return 0; }	virtual Int_t GetMinimum() const { return 0; }
	virtual Int_t GetNdata() const { return fNdata; }	virtual Int_t GetNdata() const { return fNdata; }
	virtual Int_t GetOffset() const { return fOffset; }	virtual Int_t GetOffset() const { return fOffset; }
	virtual void *GetValuePointer() const { return 0; }	virtual void *GetValuePointer() const { return 0; }
	virtual const char *GetTypeName() const { return ""; }	virtual const char *GetTypeName() const { return ""; }


	virtual Double_t GetValue(Int_t i = 0) const;	virtual Double_t GetValue(Int_t i = 0) const;

		virtual Long64_t GetValueLong64(Int_t i = 0) const { return GetValue(i);
		} //overload only when it matters.
		virtual LongDouble_t GetValueLongDouble(Int_t i = 0) const { return GetV
		alue(i); } // overload only when it matters.
		template <typename T > T GetTypedValue(Int_t i = 0) const { return GetVa
		lueHelper<T>::Exec(this, i); }

	virtual void Import(TClonesArray*, Int_t) {}	virtual void Import(TClonesArray*, Int_t) {}
	virtual Bool_t IsOnTerminalBranch() const { return kTRUE; }	virtual Bool_t IsOnTerminalBranch() const { return kTRUE; }
	virtual Bool_t IsRange() const { return fIsRange; }	virtual Bool_t IsRange() const { return fIsRange; }
	virtual Bool_t IsUnsigned() const { return fIsUnsigned; }	virtual Bool_t IsUnsigned() const { return fIsUnsigned; }
	virtual void PrintValue(Int_t i = 0) const;	virtual void PrintValue(Int_t i = 0) const;
	virtual void ReadBasket(TBuffer&) {}	virtual void ReadBasket(TBuffer&) {}
	virtual void ReadBasketExport(TBuffer&, TClonesArray*, Int_t) {}	virtual void ReadBasketExport(TBuffer&, TClonesArray*, Int_t) {}
	virtual void ReadValue(istream& /s/, Char_t /delim/ = ' ') {	virtual void ReadValue(istream& /s/, Char_t /delim/ = ' ') {
	Error("ReadValue", "Not implemented!");	Error("ReadValue", "Not implemented!");
	}	}

	skipping to change at line 99	skipping to change at line 108
	virtual void SetBranch(TBranch* branch) { fBranch = branch; }	virtual void SetBranch(TBranch* branch) { fBranch = branch; }
	virtual void SetLeafCount(TLeaf* leaf);	virtual void SetLeafCount(TLeaf* leaf);
	virtual void SetLen(Int_t len = 1) { fLen = len; }	virtual void SetLen(Int_t len = 1) { fLen = len; }
	virtual void SetOffset(Int_t offset = 0) { fOffset = offset; }	virtual void SetOffset(Int_t offset = 0) { fOffset = offset; }
	virtual void SetRange(Bool_t range = kTRUE) { fIsRange = range; }	virtual void SetRange(Bool_t range = kTRUE) { fIsRange = range; }
	virtual void SetUnsigned() { fIsUnsigned = kTRUE; }	virtual void SetUnsigned() { fIsUnsigned = kTRUE; }

	ClassDef(TLeaf,2); //Leaf: description of a Branch data type	ClassDef(TLeaf,2); //Leaf: description of a Branch data type
	};	};


		template <> struct TLeaf::GetValueHelper<Long64_t> {
		static Long64_t Exec(const TLeaf *leaf, Int_t i = 0) { return leaf->GetV
		alueLong64(i); }
		};
		template <> struct TLeaf::GetValueHelper<ULong64_t> {
		static ULong64_t Exec(const TLeaf *leaf, Int_t i = 0) { return (ULong64_
		t)leaf->GetValueLong64(i); }
		};
		template <> struct TLeaf::GetValueHelper<LongDouble_t> {
		static LongDouble_t Exec(const TLeaf *leaf, Int_t i = 0) { return leaf->
		GetValueLongDouble(i); }
		};

	inline Double_t TLeaf::GetValue(Int_t /i = 0/) const { return 0.0; }	inline Double_t TLeaf::GetValue(Int_t /i = 0/) const { return 0.0; }
	inline void TLeaf::PrintValue(Int_t /* i = 0*/) const {}	inline void TLeaf::PrintValue(Int_t /* i = 0*/) const {}
	inline void TLeaf::SetAddress(void* /* add = 0 */) {}	inline void TLeaf::SetAddress(void* /* add = 0 */) {}

	#endif	#endif

End of changes. 4 change blocks.
	0 lines changed or deleted	26 lines changed or added

	TLeafElement.h	TLeafElement.h

	skipping to change at line 49	skipping to change at line 49
	public:	public:
	TLeafElement();	TLeafElement();
	TLeafElement(TBranch parent, const char name, Int_t id, Int_t type);	TLeafElement(TBranch parent, const char name, Int_t id, Int_t type);
	virtual ~TLeafElement();	virtual ~TLeafElement();

	virtual Int_t GetLen() const {return ((TBranchElement)fBranch)->GetN data()fLen;}	virtual Int_t GetLen() const {return ((TBranchElement)fBranch)->GetN data()fLen;}
	TMethodCall GetMethodCall(const char name);	TMethodCall GetMethodCall(const char name);
	virtual Int_t GetMaximum() const {return ((TBranchElement*)fBranch)-> GetMaximum();}	virtual Int_t GetMaximum() const {return ((TBranchElement*)fBranch)-> GetMaximum();}
	virtual Int_t GetNdata() const {return ((TBranchElement)fBranch)->Ge tNdata()fLen;}	virtual Int_t GetNdata() const {return ((TBranchElement)fBranch)->Ge tNdata()fLen;}
	virtual const char GetTypeName() const {return ((TBranchElement)fBranc h)->GetTypeName();}	virtual const char GetTypeName() const {return ((TBranchElement)fBranc h)->GetTypeName();}

	virtual Double_t GetValue(Int_t i=0) const {return ((TBranchElement*)fBr
	anch)->GetValue(i, fLen, kFALSE);}	virtual Double_t GetValue(Int_t i=0) const { return ((TBranchElement
	virtual Double_t GetValueSubArray(Int_t i=0, Int_t j=0) const {return ((	*)fBranch)->GetValue(i, fLen, kFALSE);}
	TBranchElement*)fBranch)->GetValue(i, j, kTRUE);}	virtual Long64_t GetValueLong64(Int_t i = 0) const { return ((TBranc
		hElement*)fBranch)->GetTypedValue<Long64_t>(i, fLen, kFALSE); }
		virtual LongDouble_t GetValueLongDouble(Int_t i = 0) const { return ((TB
		ranchElement*)fBranch)->GetTypedValue<LongDouble_t>(i, fLen, kFALSE); }
		template<typename T> T GetTypedValueSubArray(Int_t i=0, Int_t j=0) const
		{return ((TBranchElement*)fBranch)->GetTypedValue<T>(i, j, kTRUE);}

	virtual void GetValuePointer() const { return ((TBranchElement)fBra nch)->GetValuePointer(); }	virtual void GetValuePointer() const { return ((TBranchElement)fBra nch)->GetValuePointer(); }
	virtual Bool_t IsOnTerminalBranch() const;	virtual Bool_t IsOnTerminalBranch() const;
	virtual void PrintValue(Int_t i=0) const {((TBranchElement*)fBranch) ->PrintValue(i);}	virtual void PrintValue(Int_t i=0) const {((TBranchElement*)fBranch) ->PrintValue(i);}
	virtual void SetLeafCount(TLeaf *leaf) {fLeafCount = leaf;}	virtual void SetLeafCount(TLeaf *leaf) {fLeafCount = leaf;}

	ClassDef(TLeafElement,1); //A TLeaf for a general object derived from T Object.	ClassDef(TLeafElement,1); //A TLeaf for a general object derived from T Object.
	};	};

	#endif	#endif

End of changes. 1 change blocks.
	4 lines changed or deleted	10 lines changed or added

	TLeafL.h	TLeafL.h

	skipping to change at line 45	skipping to change at line 45
	public:	public:
	TLeafL();	TLeafL();
	TLeafL(TBranch parent, const char name, const char *type);	TLeafL(TBranch parent, const char name, const char *type);
	virtual ~TLeafL();	virtual ~TLeafL();

	virtual void Export(TClonesArray *list, Int_t n);	virtual void Export(TClonesArray *list, Int_t n);
	virtual void FillBasket(TBuffer &b);	virtual void FillBasket(TBuffer &b);
	const char *GetTypeName() const;	const char *GetTypeName() const;
	virtual Int_t GetMaximum() const {return (Int_t)fMaximum;}	virtual Int_t GetMaximum() const {return (Int_t)fMaximum;}
	virtual Int_t GetMinimum() const {return (Int_t)fMinimum;}	virtual Int_t GetMinimum() const {return (Int_t)fMinimum;}

	Double_t GetValue(Int_t i=0) const;	virtual Double_t GetValue(Int_t i=0) const;
		virtual Long64_t GetValueLong64(Int_t i = 0) const ;
		virtual LongDouble_t GetValueLongDouble(Int_t i = 0) const;
	virtual void *GetValuePointer() const {return fValue;}	virtual void *GetValuePointer() const {return fValue;}
	virtual void Import(TClonesArray *list, Int_t n);	virtual void Import(TClonesArray *list, Int_t n);
	virtual void PrintValue(Int_t i=0) const;	virtual void PrintValue(Int_t i=0) const;
	virtual void ReadBasket(TBuffer &b);	virtual void ReadBasket(TBuffer &b);
	virtual void ReadBasketExport(TBuffer &b, TClonesArray *list, Int_t n );	virtual void ReadBasketExport(TBuffer &b, TClonesArray *list, Int_t n );
	virtual void ReadValue(istream& s, Char_t delim = ' ');	virtual void ReadValue(istream& s, Char_t delim = ' ');
	virtual void SetAddress(void *add=0);	virtual void SetAddress(void *add=0);
	virtual void SetMaximum(Long64_t max) {fMaximum = max;}	virtual void SetMaximum(Long64_t max) {fMaximum = max;}
	virtual void SetMinimum(Long64_t min) {fMinimum = min;}	virtual void SetMinimum(Long64_t min) {fMinimum = min;}

	ClassDef(TLeafL,1); //A TLeaf for a 64 bit Integer data type.	ClassDef(TLeafL,1); //A TLeaf for a 64 bit Integer data type.
	};	};


		// if leaf is a simple type, i must be set to 0
		// if leaf is an array, i is the array element number to be returned
		inline Long64_t TLeafL::GetValueLong64(Int_t i) const { return fValue[i]; }

	#endif	#endif

End of changes. 2 change blocks.
	1 lines changed or deleted	7 lines changed or added

	TMath.h	TMath.h

	skipping to change at line 163	skipping to change at line 163
	inline Int_t CeilNint(Double_t x);	inline Int_t CeilNint(Double_t x);
	inline Double_t Floor(Double_t x);	inline Double_t Floor(Double_t x);
	inline Int_t FloorNint(Double_t x);	inline Int_t FloorNint(Double_t x);
	template<typename T>	template<typename T>
	inline Int_t Nint(T x);	inline Int_t Nint(T x);

	inline Double_t Sqrt(Double_t x);	inline Double_t Sqrt(Double_t x);
	inline Double_t Exp(Double_t x);	inline Double_t Exp(Double_t x);
	inline Double_t Ldexp(Double_t x, Int_t exp);	inline Double_t Ldexp(Double_t x, Int_t exp);
	Double_t Factorial(Int_t i);	Double_t Factorial(Int_t i);

		inline LongDouble_t Power(LongDouble_t x, LongDouble_t y);
		inline LongDouble_t Power(LongDouble_t x, Long64_t y);
		inline LongDouble_t Power(Long64_t x, Long64_t y);
	inline Double_t Power(Double_t x, Double_t y);	inline Double_t Power(Double_t x, Double_t y);
	inline Double_t Power(Double_t x, Int_t y);	inline Double_t Power(Double_t x, Int_t y);
	inline Double_t Log(Double_t x);	inline Double_t Log(Double_t x);
	Double_t Log2(Double_t x);	Double_t Log2(Double_t x);
	inline Double_t Log10(Double_t x);	inline Double_t Log10(Double_t x);
	inline Int_t Finite(Double_t x);	inline Int_t Finite(Double_t x);
	inline Int_t IsNaN(Double_t x);	inline Int_t IsNaN(Double_t x);

	inline Double_t QuietNaN();	inline Double_t QuietNaN();
	inline Double_t SignalingNaN();	inline Double_t SignalingNaN();

	skipping to change at line 489	skipping to change at line 492
	}	}
	return i;	return i;
	}	}

	inline Double_t TMath::Exp(Double_t x)	inline Double_t TMath::Exp(Double_t x)
	{ return exp(x); }	{ return exp(x); }

	inline Double_t TMath::Ldexp(Double_t x, Int_t exp)	inline Double_t TMath::Ldexp(Double_t x, Int_t exp)
	{ return ldexp(x, exp); }	{ return ldexp(x, exp); }


		inline LongDouble_t TMath::Power(LongDouble_t x, LongDouble_t y)
		{ return std::pow(x,y); }

		inline LongDouble_t TMath::Power(LongDouble_t x, Long64_t y)
		{ return std::pow(x,(LongDouble_t)y); }

		inline LongDouble_t TMath::Power(Long64_t x, Long64_t y)
		#if __cplusplus >= 201103 /C++11/
		{ return std::pow(x,y); }
		#else
		{ return std::pow((LongDouble_t)x,(LongDouble_t)y); }
		#endif

	inline Double_t TMath::Power(Double_t x, Double_t y)	inline Double_t TMath::Power(Double_t x, Double_t y)
	{ return pow(x, y); }	{ return pow(x, y); }

	inline Double_t TMath::Power(Double_t x, Int_t y) {	inline Double_t TMath::Power(Double_t x, Int_t y) {
	#ifdef R__ANSISTREAM	#ifdef R__ANSISTREAM
	return std::pow(x, y);	return std::pow(x, y);
	#else	#else
	return pow(x, (Double_t) y);	return pow(x, (Double_t) y);
	#endif	#endif
	}	}

End of changes. 2 change blocks.
	0 lines changed or deleted	16 lines changed or added

	TMathBase.h	TMathBase.h

	// @(#)root/base:$Id$	// @(#)root/base:
	// Authors: Rene Brun, Fons Rademakers 29/07/95	// Authors: Rene Brun, Fons Rademakers 29/07/95

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 41	skipping to change at line 41

	namespace TMath {	namespace TMath {

	// Abs	// Abs
	inline Short_t Abs(Short_t d);	inline Short_t Abs(Short_t d);
	inline Int_t Abs(Int_t d);	inline Int_t Abs(Int_t d);
	inline Long_t Abs(Long_t d);	inline Long_t Abs(Long_t d);
	inline Long64_t Abs(Long64_t d);	inline Long64_t Abs(Long64_t d);
	inline Float_t Abs(Float_t d);	inline Float_t Abs(Float_t d);
	inline Double_t Abs(Double_t d);	inline Double_t Abs(Double_t d);

		inline LongDouble_t Abs(LongDouble_t d);

	// Even/Odd	// Even/Odd
	inline Bool_t Even(Long_t a);	inline Bool_t Even(Long_t a);
	inline Bool_t Odd(Long_t a);	inline Bool_t Odd(Long_t a);

	// Sign	// Sign
	inline Short_t Sign(Short_t a, Short_t b);	inline Short_t Sign(Short_t a, Short_t b);
	inline Int_t Sign(Int_t a, Int_t b);	inline Int_t Sign(Int_t a, Int_t b);
	inline Long_t Sign(Long_t a, Long_t b);	inline Long_t Sign(Long_t a, Long_t b);
	inline Long64_t Sign(Long64_t a, Long64_t b);	inline Long64_t Sign(Long64_t a, Long64_t b);

	skipping to change at line 116	skipping to change at line 117

	inline Long64_t TMath::Abs(Long64_t d)	inline Long64_t TMath::Abs(Long64_t d)
	{ return (d >= 0) ? d : -d; }	{ return (d >= 0) ? d : -d; }

	inline Float_t TMath::Abs(Float_t d)	inline Float_t TMath::Abs(Float_t d)
	{ return (d >= 0) ? d : -d; }	{ return (d >= 0) ? d : -d; }

	inline Double_t TMath::Abs(Double_t d)	inline Double_t TMath::Abs(Double_t d)
	{ return (d >= 0) ? d : -d; }	{ return (d >= 0) ? d : -d; }


		inline LongDouble_t TMath::Abs(LongDouble_t d)
		{ return (d >= 0) ? d : -d; }

	//---- Sign --------------------------------------------------------------- -----	//---- Sign --------------------------------------------------------------- -----

	inline Short_t TMath::Sign(Short_t a, Short_t b)	inline Short_t TMath::Sign(Short_t a, Short_t b)
	{ return (b >= 0) ? Abs(a) : Short_t(-Abs(a)); }	{ return (b >= 0) ? Abs(a) : Short_t(-Abs(a)); }

	inline Int_t TMath::Sign(Int_t a, Int_t b)	inline Int_t TMath::Sign(Int_t a, Int_t b)
	{ return (b >= 0) ? Abs(a) : -Abs(a); }	{ return (b >= 0) ? Abs(a) : -Abs(a); }

	inline Long_t TMath::Sign(Long_t a, Long_t b)	inline Long_t TMath::Sign(Long_t a, Long_t b)
	{ return (b >= 0) ? Abs(a) : -Abs(a); }	{ return (b >= 0) ? Abs(a) : -Abs(a); }

End of changes. 3 change blocks.
	1 lines changed or deleted	5 lines changed or added

	TMathText.h	TMathText.h

	skipping to change at line 67	skipping to change at line 67
	Double_t GetXsize(void);	Double_t GetXsize(void);
	Double_t GetYsize(void);	Double_t GetYsize(void);
	virtual void Paint(Option_t *option = "");	virtual void Paint(Option_t *option = "");
	virtual void PaintMathText(	virtual void PaintMathText(
	Double_t x, Double_t y, Double_t angle, Double_t siz e,	Double_t x, Double_t y, Double_t angle, Double_t siz e,
	const char *text);	const char *text);
	virtual void SavePrimitive(	virtual void SavePrimitive(
	std::ostream &out, Option_t *option = "");	std::ostream &out, Option_t *option = "");
	friend class TMathTextRenderer;	friend class TMathTextRenderer;


	ClassDef(TMathText,1)	ClassDef(TMathText,1) //TeX mathematical formula
	};	};

	#endif	#endif

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	TPadPainter.h	TPadPainter.h

	#ifndef ROOT_TGLPadPainter	// @(#)root/gpad:$Id$
	#define ROOT_TGLPadPainter	// Author: Olivier Couet, Timur Pocheptsov 06/05/2009

		/*************************************************************************
		* Copyright (C) 1995-2009, Rene Brun and Fons Rademakers. *
		* All rights reserved. *
		* *
		* For the licensing terms see $ROOTSYS/LICENSE. *
		* For the list of contributors see $ROOTSYS/README/CREDITS. *
		*************************************************************************/

		#ifndef ROOT_TPadPainter
		#define ROOT_TPadPainter

	#ifndef ROOT_TVirtualPadPainter	#ifndef ROOT_TVirtualPadPainter
	#include "TVirtualPadPainter.h"	#include "TVirtualPadPainter.h"
	#endif	#endif

	/*	/*
	TVirtualPadPainter is an attempt to abstract	TVirtualPadPainter is an attempt to abstract
	painting operation furthermore. gVirtualX can	painting operation furthermore. gVirtualX can
	be X11 or GDI, but pad painter can be gVirtualX (X11 or GDI),	be X11 or GDI, but pad painter can be gVirtualX (X11 or GDI),
	or gl pad painter.	or gl pad painter.

End of changes. 1 change blocks.
	2 lines changed or deleted	13 lines changed or added

	TSQLiteRow.h	TSQLiteRow.h

	// @(#)root/sqlite:$Id$	// @(#)root/sqlite:
	// Author: o.freyermuth <o.f@cern.ch>, 01/06/2013	// Author: o.freyermuth <o.f@cern.ch>, 01/06/2013

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2013, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2013, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	#ifndef ROOT_TPgSQLRow	#ifndef ROOT_TSQLiteRow
	#define ROOT_TPgSQLRow	#define ROOT_TSQLiteRow

	#ifndef ROOT_TSQLRow	#ifndef ROOT_TSQLRow
	#include "TSQLRow.h"	#include "TSQLRow.h"
	#endif	#endif

	#if !defined(__CINT__)	#if !defined(__CINT__)
	#include <sqlite3.h>	#include <sqlite3.h>
	#else	#else
	struct sqlite3_stmt;	struct sqlite3_stmt;
	#endif	#endif

End of changes. 2 change blocks.
	3 lines changed or deleted	3 lines changed or added

	TTreeIndex.h	TTreeIndex.h

	skipping to change at line 36	skipping to change at line 36
	#ifndef ROOT_TTreeFormula	#ifndef ROOT_TTreeFormula
	#include "TTreeFormula.h"	#include "TTreeFormula.h"
	#endif	#endif

	class TTreeIndex : public TVirtualIndex {	class TTreeIndex : public TVirtualIndex {

	protected:	protected:
	TString fMajorName; // Index major name	TString fMajorName; // Index major name
	TString fMinorName; // Index minor name	TString fMinorName; // Index minor name
	Long64_t fN; // Number of entries	Long64_t fN; // Number of entries

	Long64_t *fIndexValues; //[fN] Sorted index values	Long64_t *fIndexValues; //[fN] Sorted index values, higher
		64bits
		Long64_t *fIndexValuesMinor; //[fN] Sorted index values, lower 6
		4bits
	Long64_t *fIndex; //[fN] Index of sorted values	Long64_t *fIndex; //[fN] Index of sorted values
	TTreeFormula *fMajorFormula; //! Pointer to major TreeFormula	TTreeFormula *fMajorFormula; //! Pointer to major TreeFormula
	TTreeFormula *fMinorFormula; //! Pointer to minor TreeFormula	TTreeFormula *fMinorFormula; //! Pointer to minor TreeFormula
	TTreeFormula *fMajorFormulaParent; //! Pointer to major TreeFormula in Parent tree (if any)	TTreeFormula *fMajorFormulaParent; //! Pointer to major TreeFormula in Parent tree (if any)
	TTreeFormula *fMinorFormulaParent; //! Pointer to minor TreeFormula in Parent tree (if any)	TTreeFormula *fMinorFormulaParent; //! Pointer to minor TreeFormula in Parent tree (if any)

	private:	private:
	TTreeIndex(const TTreeIndex&); // Not implemented.	TTreeIndex(const TTreeIndex&); // Not implemented.
	TTreeIndex &operator=(const TTreeIndex&); // Not implemented.	TTreeIndex &operator=(const TTreeIndex&); // Not implemented.

	public:	public:
	TTreeIndex();	TTreeIndex();
	TTreeIndex(const TTree T, const char majorname, const char *minorname) ;	TTreeIndex(const TTree T, const char majorname, const char *minorname) ;
	virtual ~TTreeIndex();	virtual ~TTreeIndex();
	virtual void Append(const TVirtualIndex *,Bool_t delaySort = k FALSE);	virtual void Append(const TVirtualIndex *,Bool_t delaySort = k FALSE);

		bool ConvertOldToNew();
		Long64_t FindValues(Long64_t major, Long64_t minor) const;
	virtual Long64_t GetEntryNumberFriend(const TTree *parent);	virtual Long64_t GetEntryNumberFriend(const TTree *parent);

	virtual Long64_t GetEntryNumberWithIndex(Int_t major, Int_t minor)	virtual Long64_t GetEntryNumberWithIndex(Long64_t major, Long64_t
	const;	minor) const;
	virtual Long64_t GetEntryNumberWithBestIndex(Int_t major, Int_t mi	virtual Long64_t GetEntryNumberWithBestIndex(Long64_t major, Long6
	nor) const;	4_t minor) const;
	virtual Long64_t *GetIndexValues() const {return fIndexValues;}
	virtual Long64_t *GetIndex() const {return fIndex;}	virtual Long64_t *GetIndex() const {return fIndex;}

		virtual Long64_t *GetIndexValues() const {return fIndexValues;}
		virtual Long64_t *GetIndexValuesMinor() const;
	const char *GetMajorName() const {return fMajorName.Data() ;}	const char *GetMajorName() const {return fMajorName.Data() ;}
	const char *GetMinorName() const {return fMinorName.Data() ;}	const char *GetMinorName() const {return fMinorName.Data() ;}
	virtual Long64_t GetN() const {return fN;}	virtual Long64_t GetN() const {return fN;}
	virtual TTreeFormula *GetMajorFormula();	virtual TTreeFormula *GetMajorFormula();
	virtual TTreeFormula *GetMinorFormula();	virtual TTreeFormula *GetMinorFormula();
	virtual TTreeFormula GetMajorFormulaParent(const TTree parent);	virtual TTreeFormula GetMajorFormulaParent(const TTree parent);
	virtual TTreeFormula GetMinorFormulaParent(const TTree parent);	virtual TTreeFormula GetMinorFormulaParent(const TTree parent);
	virtual void Print(Option_t *option="") const;	virtual void Print(Option_t *option="") const;
	virtual void UpdateFormulaLeaves(const TTree *parent);	virtual void UpdateFormulaLeaves(const TTree *parent);
	virtual void SetTree(const TTree *T);	virtual void SetTree(const TTree *T);


	ClassDef(TTreeIndex,1); //A Tree Index with majorname and minorname.	ClassDef(TTreeIndex,2); //A Tree Index with majorname and minorname.
	};	};

	#endif	#endif

End of changes. 5 change blocks.
	7 lines changed or deleted	13 lines changed or added

	TVirtualIndex.h	TVirtualIndex.h

	skipping to change at line 39	skipping to change at line 39
	class TVirtualIndex : public TNamed {	class TVirtualIndex : public TNamed {

	protected:	protected:
	TTree *fTree; //! pointer to Tree	TTree *fTree; //! pointer to Tree

	public:	public:
	TVirtualIndex();	TVirtualIndex();
	virtual ~TVirtualIndex();	virtual ~TVirtualIndex();
	virtual void Append(const TVirtualIndex *,Bool_t delaySort = k FALSE) = 0;	virtual void Append(const TVirtualIndex *,Bool_t delaySort = k FALSE) = 0;
	virtual Long64_t GetEntryNumberFriend(const TTree * /parent/) = 0;	virtual Long64_t GetEntryNumberFriend(const TTree * /parent/) = 0;

	virtual Long64_t GetEntryNumberWithIndex(Int_t major, Int_t minor)	virtual Long64_t GetEntryNumberWithIndex(Long64_t major, Long64_t
	const = 0;	minor) const = 0;
	virtual Long64_t GetEntryNumberWithBestIndex(Int_t major, Int_t mi	virtual Long64_t GetEntryNumberWithBestIndex(Long64_t major, Long6
	nor) const = 0;	4_t minor) const = 0;
	virtual const char *GetMajorName() const = 0;	virtual const char *GetMajorName() const = 0;
	virtual const char *GetMinorName() const = 0;	virtual const char *GetMinorName() const = 0;
	virtual Long64_t GetN() const = 0;	virtual Long64_t GetN() const = 0;
	virtual TTree *GetTree() const {return fTree;}	virtual TTree *GetTree() const {return fTree;}
	virtual void UpdateFormulaLeaves(const TTree *parent) = 0;	virtual void UpdateFormulaLeaves(const TTree *parent) = 0;
	virtual void SetTree(const TTree *T) = 0;	virtual void SetTree(const TTree *T) = 0;

	ClassDef(TVirtualIndex,1); //Abstract interface for Tree Index	ClassDef(TVirtualIndex,1); //Abstract interface for Tree Index
	};	};


End of changes. 1 change blocks.
	4 lines changed or deleted	4 lines changed or added

	compiledata.h	compiledata.h
	/* This is file is automatically generated */	/* This is file is automatically generated */
	#define BUILD_ARCH "linux"	#define BUILD_ARCH "linux"
	#define BUILD_NODE "Linux lxbuild102.cern.ch 2.6.18-308.11.1.el5 #1 SMP Tue Jul 10 16:05:16 CEST 2012 i686 i686 i386 GNU/Linux"	#define BUILD_NODE "Linux lxbuild102.cern.ch 2.6.18-308.11.1.el5 #1 SMP Tue Jul 10 16:05:16 CEST 2012 i686 i686 i386 GNU/Linux"
	#define CXX "g++"	#define CXX "g++"
	#define COMPILER "/afs/cern.ch/sw/lcg/contrib/gcc/4.3.6/i686-slc5-gcc43-opt /bin/g++"	#define COMPILER "/afs/cern.ch/sw/lcg/contrib/gcc/4.3.6/i686-slc5-gcc43-opt /bin/g++"
	#define COMPILERVERS "gcc436"	#define COMPILERVERS "gcc436"

	#define MAKESHAREDLIB "cd $BuildDir ; g++ -c $Opt -pipe -m32 -Wall -W -Wov	#define MAKESHAREDLIB "cd $BuildDir ; g++ -c $Opt -pipe -m32 -msse -mfpmat
	erloaded-virtual -fPIC -pthread $IncludePath $SourceFiles ; g++ $ObjectFile	h=sse -Wall -W -Woverloaded-virtual -fPIC -pthread $IncludePath $SourceFile
	s -shared -Wl,-soname,$LibName.so -m32 -O2 -Wl,--no-undefined -Wl,--as-nee	s ; g++ $ObjectFiles -shared -Wl,-soname,$LibName.so -m32 -O2 -Wl,--no-und
	ded $LinkedLibs -o $SharedLib"	efined -Wl,--as-needed $LinkedLibs -o $SharedLib"
	#define MAKEEXE "cd $BuildDir ; g++ -c -pipe -m32 -Wall -W -Woverloaded-vi	#define MAKEEXE "cd $BuildDir ; g++ -c -pipe -m32 -msse -mfpmath=sse -Wall
	rtual -fPIC -pthread $IncludePath $SourceFiles; g++ $ObjectFiles -m32 -O2	-W -Woverloaded-virtual -fPIC -pthread $IncludePath $SourceFiles; g++ $Obj
	-Wl,--no-undefined -Wl,--as-needed -o $ExeName $LinkedLibs -lm -ldl -pthre	ectFiles -m32 -O2 -Wl,--no-undefined -Wl,--as-needed -o $ExeName $LinkedLi
	ad -rdynamic"	bs -lm -ldl -pthread -rdynamic"
	#define CXXOPT "-O2"	#define CXXOPT "-O2"
	#define CXXDEBUG "-g"	#define CXXDEBUG "-g"
	#define ROOTBUILD ""	#define ROOTBUILD ""
	#define LINKEDLIBS "-L$ROOTSYS/lib -lCore -lCint -lRint "	#define LINKEDLIBS "-L$ROOTSYS/lib -lCore -lCint -lRint "
	#define INCLUDEPATH "-I$ROOTSYS/include"	#define INCLUDEPATH "-I$ROOTSYS/include"
	#define OBJEXT "o"	#define OBJEXT "o"
	#define SOEXT "so"	#define SOEXT "so"

End of changes. 1 change blocks.
	8 lines changed or deleted	8 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/

	FitConfig.h	FitConfig.h

	skipping to change at line 184	skipping to change at line 184
	const std::vector<unsigned int> & MinosParams() const { return fMinosPar ams; }	const std::vector<unsigned int> & MinosParams() const { return fMinosPar ams; }

	/**	/**
	set the option to normalize the error on the result according to chi 2/ndf	set the option to normalize the error on the result according to chi 2/ndf
	*/	*/
	void SetNormErrors(bool on = true) { fNormErrors= on; }	void SetNormErrors(bool on = true) { fNormErrors= on; }

	///set parabolic erros	///set parabolic erros
	void SetParabErrors(bool on = true) { fParabErrors = on; }	void SetParabErrors(bool on = true) { fParabErrors = on; }


	///set Minos erros	///set Minos erros computation to be performed after fitting
	void SetMinosErrors(bool on = true) { fMinosErrors = on; }	void SetMinosErrors(bool on = true) { fMinosErrors = on; }

	///apply the weight correction for error matric computation	///apply the weight correction for error matric computation
	void SetWeightCorrection(bool on = true) { fWeightCorr = on; }	void SetWeightCorrection(bool on = true) { fWeightCorr = on; }

	/// set parameter indeces for running Minos	/// set parameter indeces for running Minos
	/// this can be used for running Minos on a subset of parameters - other wise is run on all of them	/// this can be used for running Minos on a subset of parameters - other wise is run on all of them
	/// if MinosErrors() is set	/// if MinosErrors() is set
	void SetMinosErrors(const std::vector<unsigned int> & paramInd ) {	void SetMinosErrors(const std::vector<unsigned int> & paramInd ) {
	fMinosErrors = true;	fMinosErrors = true;

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	GSLMultiRootFinder.h	GSLMultiRootFinder.h

	skipping to change at line 162	skipping to change at line 162
	/// set the type using a string	/// set the type using a string
	void SetType(const char * name);	void SetType(const char * name);

	/*	/*
	add the list of functions f1(x1,..xn),...fn(x1,...xn). The list must contain pointers of	add the list of functions f1(x1,..xn),...fn(x1,...xn). The list must contain pointers of
	ROOT::Math::IMultiGenFunctions. The method requires the	ROOT::Math::IMultiGenFunctions. The method requires the
	the begin and end of the list iterator.	the begin and end of the list iterator.
	The list can be any stl container or a simple array of ROOT::Math:: IMultiGenFunctions* or	The list can be any stl container or a simple array of ROOT::Math:: IMultiGenFunctions* or
	whatever implementing an iterator.	whatever implementing an iterator.
	If using a derivative type algorithm the function pointers must impl ement the	If using a derivative type algorithm the function pointers must impl ement the

	ROOOT::Math::IMultiGradFunction interface	ROOT::Math::IMultiGradFunction interface
	*/	*/
	template<class FuncIterator>	template<class FuncIterator>
	bool SetFunctionList( FuncIterator begin, FuncIterator end) {	bool SetFunctionList( FuncIterator begin, FuncIterator end) {
	bool ret = true;	bool ret = true;
	for (FuncIterator itr = begin; itr != end; ++itr) {	for (FuncIterator itr = begin; itr != end; ++itr) {
	const ROOT::Math::IMultiGenFunction * f = *itr;	const ROOT::Math::IMultiGenFunction * f = *itr;
	ret &= AddFunction( *f);	ret &= AddFunction( *f);
	}	}
	return ret;	return ret;
	}	}

	/*	/*
	add (set) a single function fi(x1,...xn) which is part of the system of	add (set) a single function fi(x1,...xn) which is part of the system of
	specifying the begin and end of the iterator.	specifying the begin and end of the iterator.
	If using a derivative type algorithm the function must implement the	If using a derivative type algorithm the function must implement the

	ROOOT::Math::IMultiGradFunction interface	ROOT::Math::IMultiGradFunction interface
	Return the current number of function in the list and 0 if failed to add the function	Return the current number of function in the list and 0 if failed to add the function
	*/	*/
	int AddFunction( const ROOT::Math::IMultiGenFunction & func);	int AddFunction( const ROOT::Math::IMultiGenFunction & func);

	/// same method as before but using any function implementing	/// same method as before but using any function implementing
	/// the operator(), so can be wrapped in a IMultiGenFunction interface	/// the operator(), so can be wrapped in a IMultiGenFunction interface
	template <class Function>	template <class Function>
	int AddFunction( Function & f, int ndim) {	int AddFunction( Function & f, int ndim) {
	// no need to care about lifetime of wfunc. It will be cloned inside AddFunction	// no need to care about lifetime of wfunc. It will be cloned inside AddFunction
	WrappedMultiFunction<Function &> wfunc(f, ndim);	WrappedMultiFunction<Function &> wfunc(f, ndim);

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	Hoption.h	Hoption.h

	skipping to change at line 37	skipping to change at line 37
	int Curve; // "C" A smooth Curve is drawn.	int Curve; // "C" A smooth Curve is drawn.
	int Error; // "E" Draw Errors with current marker type and size.	int Error; // "E" Draw Errors with current marker type and size.
	int Fill; // "F" A fill area is drawn ("CF" draw a smooth fill a rea).	int Fill; // "F" A fill area is drawn ("CF" draw a smooth fill a rea).
	int Off; // "][" With H option, the first and last vertical line s are not drawn.	int Off; // "][" With H option, the first and last vertical line s are not drawn.
	int Keep; // "K" The status of the histogram is kept in memory	int Keep; // "K" The status of the histogram is kept in memory
	int Line; // "L" A simple polyline beetwen every point is drawn.	int Line; // "L" A simple polyline beetwen every point is drawn.
	int Mark; // "P" The current Marker is drawn at each point	int Mark; // "P" The current Marker is drawn at each point
	int Same; // "S" Histogram is plotted in the current PAD.	int Same; // "S" Histogram is plotted in the current PAD.
	int Update; // "U" Update histogram previously plotted with option K	int Update; // "U" Update histogram previously plotted with option K
	int Star; // "" A is plotted at each point	int Star; // "" A is plotted at each point

	int Arrow; // "ARR" Draw 2D plot with Arrows.	int Arrow; // "ARR" Draw 2D plot with Arrows.
	int Box; // "BOX" Draw 2D plot with proportional Boxes.	int Box; // "BOX" Draw 2D plot with proportional Boxes.
	int Char; // "CHAR" Draw 2D plot with a character set.	int Char; // "CHAR" Draw 2D plot with a character set.
	int Color; // "COL" Draw 2D plot with Colored boxes.	int Color; // "COL" Draw 2D plot with Colored boxes.
	int Contour; // "CONT" Draw 2D plot as a Contour plot.	int Contour; // "CONT" Draw 2D plot as a Contour plot.
	int Func; // "FUNC" Draw only the function (for example in case	int Func; // "FUNC" Draw only the function (for example in case
	of fit).	of fit).
	int Hist; // "HIST" Draw only the histogram.	int Hist; // "HIST" Draw only the histogram.
	int Lego; // "LEGO" Draw as a Lego plot(LEGO,Lego=1, LEGO1,Lego1	int Lego; // "LEGO" Draw as a Lego plot(LEGO,Lego=1, LEGO1,Lego
	=11, LEGO2,Lego=12).	1=11, LEGO2,Lego=12).
	int Scat; // "SCAT" Draw 2D plot a Scatter plot.	int Scat; // "SCAT" Draw 2D plot a Scatter plot.
	int Surf; // "SURF" Draw as a Surface (SURF,Surf=1, SURF1,Surf=1	int Surf; // "SURF" Draw as a Surface (SURF,Surf=1, SURF1,Surf=
	1, SURF2,Surf=12)	11, SURF2,Surf=12)
	int Text; // "TEXT" Draw 2D plot with the content of each cell.	int Text; // "TEXT" Draw 2D plot with the content of each cell.
	int Tri; // "TRI" Draw 2D plot with Delaunay triangles.	int Tri; // "TRI" Draw 2D plot with Delaunay triangles.
	int Pie; // "PIE" Draw 1D plot as a pie chart.	int Pie; // "PIE" Draw 1D plot as a pie chart.
		int Candle; // "CANDLE" Draw a 2D histogram as candle/box plot.
	int System; // type of coordinate system(1=car,2=pol,3=cyl,4=sph,5= psr)	int System; // type of coordinate system(1=car,2=pol,3=cyl,4=sph,5= psr)
	int Zscale; // "Z" to display the Z scale (color palette)	int Zscale; // "Z" to display the Z scale (color palette)
	int FrontBox; // = 0 to suppress the front box	int FrontBox; // = 0 to suppress the front box
	int BackBox; // = 0 to suppress the back box	int BackBox; // = 0 to suppress the back box
	int List; // = 1 to generate the TObjArray "contours"	int List; // = 1 to generate the TObjArray "contours"

	int HighRes; // = 1 to select high resolution
	int Proj; // = 1 to get an Aitoff projection, usefull for skymap s or exposure maps..	int Proj; // = 1 to get an Aitoff projection, usefull for skymap s or exposure maps..
	// = 2 to get a Mercator ptojection	// = 2 to get a Mercator ptojection
	// = 3 to get a Sinusoidal ptojection	// = 3 to get a Sinusoidal ptojection
	// = 4 to get a Parabolic ptojection	// = 4 to get a Parabolic ptojection
	int AxisPos; // Axis position	int AxisPos; // Axis position
	int Spec; // TSpectrum graphics	int Spec; // TSpectrum graphics

	int Zero; // if selected with any LEGO option the empty are not d rawn.	int Zero; // if selected with any LEGO option the empty are not d rawn.

	// the following structure members are set to 1 if the corresponding opt ion	// the following structure members are set to 1 if the corresponding opt ion

End of changes. 2 change blocks.
	17 lines changed or deleted	17 lines changed or added

	MethodBase.h	MethodBase.h

	skipping to change at line 147	skipping to change at line 147
	// store and retrieve time used for training	// store and retrieve time used for training
	void SetTrainTime( Double_t trainTime ) { fTrainTime = tr ainTime; }	void SetTrainTime( Double_t trainTime ) { fTrainTime = tr ainTime; }
	Double_t GetTrainTime() const { return fTrainTime; }	Double_t GetTrainTime() const { return fTrainTime; }

	// store and retrieve time used for testing	// store and retrieve time used for testing
	void SetTestTime ( Double_t testTime ) { fTestTime = test Time; }	void SetTestTime ( Double_t testTime ) { fTestTime = test Time; }
	Double_t GetTestTime () const { return fTestTime; }	Double_t GetTestTime () const { return fTestTime; }

	// performs classifier testing	// performs classifier testing
	virtual void TestClassification();	virtual void TestClassification();

		virtual Double_t GetKSTrainingVsTest(Char_t SorB, TString opt="X");

	// performs multiclass classifier testing	// performs multiclass classifier testing
	virtual void TestMulticlass();	virtual void TestMulticlass();

	// performs regression testing	// performs regression testing
	virtual void TestRegression( Double_t& bias, Double_t& biasT,	virtual void TestRegression( Double_t& bias, Double_t& biasT,
	Double_t& dev, Double_t& devT,	Double_t& dev, Double_t& devT,
	Double_t& rms, Double_t& rmsT,	Double_t& rms, Double_t& rmsT,
	Double_t& mInf, Double_t& mInfT, // mutual information	Double_t& mInf, Double_t& mInfT, // mutual information
	Double_t& corr,	Double_t& corr,

	skipping to change at line 559	skipping to change at line 560
	TString fWeightFile; // weight file name	TString fWeightFile; // weight file name

	private:	private:

	TH1* fEffS; // efficiency histogram for ro otfinder	TH1* fEffS; // efficiency histogram for ro otfinder

	PDF* fDefaultPDF; // default PDF definitions	PDF* fDefaultPDF; // default PDF definitions
	PDF* fMVAPdfS; // signal MVA PDF	PDF* fMVAPdfS; // signal MVA PDF
	PDF* fMVAPdfB; // background MVA PDF	PDF* fMVAPdfB; // background MVA PDF


	TH1D* fmvaS; // PDFs of MVA distribution (s	// TH1D* fmvaS; // PDFs of MVA distrib
	ignal)	ution (signal)
	TH1D* fmvaB; // PDFs of MVA distribution (b	// TH1D* fmvaB; // PDFs of MVA distrib
	ackground)	ution (background)
	PDF* fSplS; // PDFs of MVA distribution (s ignal)	PDF* fSplS; // PDFs of MVA distribution (s ignal)
	PDF* fSplB; // PDFs of MVA distribution (b ackground)	PDF* fSplB; // PDFs of MVA distribution (b ackground)
	TSpline* fSpleffBvsS; // splines for signal eff. ver sus background eff.	TSpline* fSpleffBvsS; // splines for signal eff. ver sus background eff.

	PDF* fSplTrainS; // PDFs of training MVA distri bution (signal)	PDF* fSplTrainS; // PDFs of training MVA distri bution (signal)
	PDF* fSplTrainB; // PDFs of training MVA distri bution (background)	PDF* fSplTrainB; // PDFs of training MVA distri bution (background)
	TSpline* fSplTrainEffBvsS; // splines for training signal eff. versus background eff.	TSpline* fSplTrainEffBvsS; // splines for training signal eff. versus background eff.

	private:	private:


End of changes. 2 change blocks.
	4 lines changed or deleted	5 lines changed or added

	RooAbsArg.h	RooAbsArg.h

	skipping to change at line 309	skipping to change at line 309
	// Cache mode optimization (tracks changes & do lazy evaluation vs evalua te always)	// Cache mode optimization (tracks changes & do lazy evaluation vs evalua te always)
	virtual void optimizeCacheMode(const RooArgSet& observables) ;	virtual void optimizeCacheMode(const RooArgSet& observables) ;
	virtual void optimizeCacheMode(const RooArgSet& observables, RooArgSet& o ptNodes, RooLinkedList& processedNodes) ;	virtual void optimizeCacheMode(const RooArgSet& observables, RooArgSet& o ptNodes, RooLinkedList& processedNodes) ;

	// Find constant terms in expression	// Find constant terms in expression
	Bool_t findConstantNodes(const RooArgSet& observables, RooArgSet& cacheLi st) ;	Bool_t findConstantNodes(const RooArgSet& observables, RooArgSet& cacheLi st) ;
	Bool_t findConstantNodes(const RooArgSet& observables, RooArgSet& cacheLi st, RooLinkedList& processedNodes) ;	Bool_t findConstantNodes(const RooArgSet& observables, RooArgSet& cacheLi st, RooLinkedList& processedNodes) ;

	// constant term optimization	// constant term optimization
	virtual void constOptimizeTestStatistic(ConstOpCode opcode, Bool_t doAlso TrackingOpt=kTRUE) ;	virtual void constOptimizeTestStatistic(ConstOpCode opcode, Bool_t doAlso TrackingOpt=kTRUE) ;

		enum CacheMode { Always=0, NotAdvised=1, Never=2 } ;
		virtual CacheMode canNodeBeCached() const { return Always ; }
		virtual void setCacheAndTrackHints(RooArgSet& /trackNodes/ ) {} ;

	void graphVizTree(const char* fileName, const char* delimiter="\n", bool useTitle=false, bool useLatex=false) ;	void graphVizTree(const char* fileName, const char* delimiter="\n", bool useTitle=false, bool useLatex=false) ;
	void graphVizTree(std::ostream& os, const char* delimiter="\n", bool useT itle=false, bool useLatex=false) ;	void graphVizTree(std::ostream& os, const char* delimiter="\n", bool useT itle=false, bool useLatex=false) ;

	/* TGraphStruct* graph(Bool_t useFactoryTag=kFALSE, Double_t textSize=0.0 3) ; */	/* TGraphStruct* graph(Bool_t useFactoryTag=kFALSE, Double_t textSize=0.0 3) ; */

	void printComponentTree(const char* indent="",const char* namePat=0, Int_ t nLevel=999) ;	void printComponentTree(const char* indent="",const char* namePat=0, Int_ t nLevel=999) ;
	void printCompactTree(const char* indent="",const char* fileName=0, const char* namePat=0, RooAbsArg* client=0) ;	void printCompactTree(const char* indent="",const char* fileName=0, const char* namePat=0, RooAbsArg* client=0) ;
	void printCompactTree(std::ostream& os, const char* indent="", const char * namePat=0, RooAbsArg* client=0) ;	void printCompactTree(std::ostream& os, const char* indent="", const char * namePat=0, RooAbsArg* client=0) ;
	virtual void printCompactTreeHook(std::ostream& os, const char *ind="") ;	virtual void printCompactTreeHook(std::ostream& os, const char *ind="") ;

End of changes. 1 change blocks.
	0 lines changed or deleted	3 lines changed or added

	RooAbsDataStore.h	RooAbsDataStore.h

	skipping to change at line 110	skipping to change at line 110
	virtual void setArgStatus(const RooArgSet& set, Bool_t active) = 0 ;	virtual void setArgStatus(const RooArgSet& set, Bool_t active) = 0 ;
	const RooArgSet& cachedVars() const { return _cachedVars ; }	const RooArgSet& cachedVars() const { return _cachedVars ; }
	virtual void resetCache() = 0 ;	virtual void resetCache() = 0 ;
	virtual void recalculateCache(const RooArgSet* /proj/, Int_t /firstEve nt/, Int_t /lastEvent/, Int_t /stepSize/, Bool_t /* skipZeroWeights*/) {} ;	virtual void recalculateCache(const RooArgSet* /proj/, Int_t /firstEve nt/, Int_t /lastEvent/, Int_t /stepSize/, Bool_t /* skipZeroWeights*/) {} ;

	virtual void setDirtyProp(Bool_t flag) { _doDirtyProp = flag ; }	virtual void setDirtyProp(Bool_t flag) { _doDirtyProp = flag ; }
	Bool_t dirtyProp() const { return _doDirtyProp ; }	Bool_t dirtyProp() const { return _doDirtyProp ; }

	virtual void checkInit() const {} ;	virtual void checkInit() const {} ;


	Bool_t hasFilledCache() const { return _cachedVars.getSize()>0 ; }	virtual Bool_t hasFilledCache() const { return kFALSE ; }

	virtual const TTree* tree() const { return 0 ; }	virtual const TTree* tree() const { return 0 ; }
	virtual void dump() {}	virtual void dump() {}

	virtual void loadValues(const RooAbsDataStore tds, const RooFormulaVar select=0, const char* rangeName=0, Int_t nStart=0, Int_t nStop=2000000000) = 0 ;	virtual void loadValues(const RooAbsDataStore tds, const RooFormulaVar select=0, const char* rangeName=0, Int_t nStart=0, Int_t nStop=2000000000) = 0 ;


		virtual void forceCacheUpdate() {} ;

	protected:	protected:

	RooArgSet _vars ;	RooArgSet _vars ;
	RooArgSet _cachedVars ;	RooArgSet _cachedVars ;
	TIterator *_iterator; //! Iterator over dimension variables	TIterator *_iterator; //! Iterator over dimension variables
	TIterator *_cacheIter ; //! Iterator over cached variables	TIterator *_cacheIter ; //! Iterator over cached variables

	Bool_t _doDirtyProp ; // Switch do (de)activate dirty state propagatio n when loading a data point	Bool_t _doDirtyProp ; // Switch do (de)activate dirty state propagatio n when loading a data point

	ClassDef(RooAbsDataStore,1) // Abstract Data Storage class	ClassDef(RooAbsDataStore,1) // Abstract Data Storage class

End of changes. 2 change blocks.
	1 lines changed or deleted	3 lines changed or added

	RooAddPdf.h	RooAddPdf.h

	skipping to change at line 91	skipping to change at line 91
	const char* getCoefRange() const { return _refCoefRangeName?RooNameReg::s tr(_refCoefRangeName):"" ; }	const char* getCoefRange() const { return _refCoefRangeName?RooNameReg::s tr(_refCoefRangeName):"" ; }

	virtual void resetErrorCounters(Int_t resetValue=10) ;	virtual void resetErrorCounters(Int_t resetValue=10) ;

	virtual std::list<Double_t>* plotSamplingHint(RooAbsRealLValue& obs, Doub le_t xlo, Double_t xhi) const ;	virtual std::list<Double_t>* plotSamplingHint(RooAbsRealLValue& obs, Doub le_t xlo, Double_t xhi) const ;
	virtual std::list<Double_t>* binBoundaries(RooAbsRealLValue& /obs/, Dou ble_t /xlo/, Double_t /xhi/) const ;	virtual std::list<Double_t>* binBoundaries(RooAbsRealLValue& /obs/, Dou ble_t /xlo/, Double_t /xhi/) const ;
	Bool_t isBinnedDistribution(const RooArgSet& obs) const ;	Bool_t isBinnedDistribution(const RooArgSet& obs) const ;

	void printMetaArgs(std::ostream& os) const ;	void printMetaArgs(std::ostream& os) const ;


		virtual CacheMode canNodeBeCached() const { return RooAbsArg::NotAdvised
		; } ;
		virtual void setCacheAndTrackHints(RooArgSet&) ;

	protected:	protected:

	virtual void selectNormalization(const RooArgSet* depSet=0, Bool_t force= kFALSE) ;	virtual void selectNormalization(const RooArgSet* depSet=0, Bool_t force= kFALSE) ;
	virtual void selectNormalizationRange(const char* rangeName=0, Bool_t for ce=kFALSE) ;	virtual void selectNormalizationRange(const char* rangeName=0, Bool_t for ce=kFALSE) ;

	mutable RooSetProxy _refCoefNorm ; // Reference observable set for coef ficient interpretation	mutable RooSetProxy _refCoefNorm ; // Reference observable set for coef ficient interpretation
	mutable TNamed* _refCoefRangeName ; // Reference range name for coeffici ent interpreation	mutable TNamed* _refCoefRangeName ; // Reference range name for coeffici ent interpreation

	Bool_t _projectCoefs ; // If true coefficients need to be project ed for use in evaluate()	Bool_t _projectCoefs ; // If true coefficients need to be project ed for use in evaluate()
	mutable Double_t* _coefCache ; //! Transiet cache with transformed values of coefficients	mutable Double_t* _coefCache ; //! Transiet cache with transformed values of coefficients

End of changes. 1 change blocks.
	0 lines changed or deleted	4 lines changed or added

	Rtypes.h	Rtypes.h

	skipping to change at line 76	skipping to change at line 76
	typedef unsigned long ULong_t; //Unsigned long integer 8 bytes (unsign ed long)	typedef unsigned long ULong_t; //Unsigned long integer 8 bytes (unsign ed long)
	#else	#else
	typedef int Seek_t; //File pointer (int)	typedef int Seek_t; //File pointer (int)
	typedef long Long_t; //Signed long integer 4 bytes (long)	typedef long Long_t; //Signed long integer 4 bytes (long)
	typedef unsigned long ULong_t; //Unsigned long integer 4 bytes (unsign ed long)	typedef unsigned long ULong_t; //Unsigned long integer 4 bytes (unsign ed long)
	#endif	#endif
	typedef float Float_t; //Float 4 bytes (float)	typedef float Float_t; //Float 4 bytes (float)
	typedef float Float16_t; //Float 4 bytes written with a truncate d mantissa	typedef float Float16_t; //Float 4 bytes written with a truncate d mantissa
	typedef double Double_t; //Double 8 bytes	typedef double Double_t; //Double 8 bytes
	typedef double Double32_t; //Double 8 bytes in memory, written as a 4 bytes float	typedef double Double32_t; //Double 8 bytes in memory, written as a 4 bytes float

		typedef long double LongDouble_t;//Long Double
	typedef char Text_t; //General string (char)	typedef char Text_t; //General string (char)
	typedef bool Bool_t; //Boolean (0=false, 1=true) (bool)	typedef bool Bool_t; //Boolean (0=false, 1=true) (bool)
	typedef unsigned char Byte_t; //Byte (8 bits) (unsigned char)	typedef unsigned char Byte_t; //Byte (8 bits) (unsigned char)
	typedef short Version_t; //Class version identifier (short)	typedef short Version_t; //Class version identifier (short)
	typedef const char Option_t; //Option string (const char)	typedef const char Option_t; //Option string (const char)
	typedef int Ssiz_t; //String size (int)	typedef int Ssiz_t; //String size (int)
	typedef float Real_t; //TVector and TMatrix element type (flo at)	typedef float Real_t; //TVector and TMatrix element type (flo at)
	#if defined(R__WIN32) && !defined(__CINT__)	#if defined(R__WIN32) && !defined(__CINT__)
	typedef __int64 Long64_t; //Portable signed long integer 8 bytes	typedef __int64 Long64_t; //Portable signed long integer 8 bytes
	typedef unsigned __int64 ULong64_t; //Portable unsigned long integer 8 byte s	typedef unsigned __int64 ULong64_t; //Portable unsigned long integer 8 byte s

End of changes. 1 change blocks.
	0 lines changed or deleted	1 lines changed or added

	TBranchElement.h	TBranchElement.h

	skipping to change at line 98	skipping to change at line 98
	TClassRef fCurrentClass; //! Reference to current (trans ient) class definition	TClassRef fCurrentClass; //! Reference to current (trans ient) class definition
	TClassRef fParentClass; //! Reference to class definiti on in fParentName	TClassRef fParentClass; //! Reference to class definiti on in fParentName
	TClassRef fBranchClass; //! Reference to class definiti on in fClassName	TClassRef fBranchClass; //! Reference to class definiti on in fClassName
	TClassRef fClonesClass; //! Reference to class definiti on in fClonesName	TClassRef fClonesClass; //! Reference to class definiti on in fClonesName
	Int_t *fBranchOffset; //! Sub-Branch offsets with res pect to current transient class	Int_t *fBranchOffset; //! Sub-Branch offsets with res pect to current transient class
	Int_t fBranchID; //! ID number assigned by a TRe fTable.	Int_t fBranchID; //! ID number assigned by a TRe fTable.
	std::vector<Int_t> fIDs; //! List of the serial number o f all the StreamerInfo to be used.	std::vector<Int_t> fIDs; //! List of the serial number o f all the StreamerInfo to be used.
	TStreamerInfoActions::TActionSequence *fReadActionSequence; //! Set of actions to be executed to extract the data from the basket.	TStreamerInfoActions::TActionSequence *fReadActionSequence; //! Set of actions to be executed to extract the data from the basket.
	TStreamerInfoActions::TActionSequence *fFillActionSequence; //! Set of a ctions to be executed to write the data to the basket.	TStreamerInfoActions::TActionSequence *fFillActionSequence; //! Set of a ctions to be executed to write the data to the basket.
	TVirtualCollectionIterators *fIterators; //! holds the ite rators when the branch is of fType==4.	TVirtualCollectionIterators *fIterators; //! holds the ite rators when the branch is of fType==4.

		TVirtualCollectionIterators *fWriteIterators;//! holds the rea d (non-staging) iterators when the branch is of fType==4 and associative co ntainers.
	TVirtualCollectionPtrIterators *fPtrIterators; //! holds the ite rators when the branch is of fType==4 and it is a split collection of point ers.	TVirtualCollectionPtrIterators *fPtrIterators; //! holds the ite rators when the branch is of fType==4 and it is a split collection of point ers.

	// Not implemented	// Not implemented
	private:	private:
	TBranchElement(const TBranchElement&); // not implemented	TBranchElement(const TBranchElement&); // not implemented
	TBranchElement& operator=(const TBranchElement&); // not implemented	TBranchElement& operator=(const TBranchElement&); // not implemented

	static void SwitchContainer(TObjArray *);	static void SwitchContainer(TObjArray *);

	// Implementation use only functions.	// Implementation use only functions.

	skipping to change at line 147	skipping to change at line 148
	void SetReadLeavesPtr();	void SetReadLeavesPtr();
	void SetReadActionSequence();	void SetReadActionSequence();
	void SetupAddressesImpl();	void SetupAddressesImpl();

	void FillLeavesImpl(TBuffer& b);	void FillLeavesImpl(TBuffer& b);
	void FillLeavesMakeClass(TBuffer& b);	void FillLeavesMakeClass(TBuffer& b);
	void FillLeavesCollection(TBuffer& b);	void FillLeavesCollection(TBuffer& b);
	void FillLeavesCollectionSplitVectorPtrMember(TBuffer& b);	void FillLeavesCollectionSplitVectorPtrMember(TBuffer& b);
	void FillLeavesCollectionSplitPtrMember(TBuffer& b);	void FillLeavesCollectionSplitPtrMember(TBuffer& b);
	void FillLeavesCollectionMember(TBuffer& b);	void FillLeavesCollectionMember(TBuffer& b);

		void FillLeavesAssociativeCollectionMember(TBuffer& b);
	void FillLeavesClones(TBuffer& b);	void FillLeavesClones(TBuffer& b);
	void FillLeavesClonesMember(TBuffer& b);	void FillLeavesClonesMember(TBuffer& b);
	void FillLeavesCustomStreamer(TBuffer& b);	void FillLeavesCustomStreamer(TBuffer& b);
	void FillLeavesMemberBranchCount(TBuffer& b);	void FillLeavesMemberBranchCount(TBuffer& b);
	void FillLeavesMemberCounter(TBuffer& b);	void FillLeavesMemberCounter(TBuffer& b);
	void FillLeavesMember(TBuffer& b);	void FillLeavesMember(TBuffer& b);
	void SetFillLeavesPtr();	void SetFillLeavesPtr();
	void SetFillActionSequence();	void SetFillActionSequence();
	// Public Interface.	// Public Interface.
	public:	public:

	skipping to change at line 195	skipping to change at line 197
	TStreamerInfo *GetInfo() const;	TStreamerInfo *GetInfo() const;
	Bool_t GetMakeClass() const;	Bool_t GetMakeClass() const;
	char *GetObject() const;	char *GetObject() const;
	virtual const char *GetParentName() const { return fParentName.Data (); }	virtual const char *GetParentName() const { return fParentName.Data (); }
	virtual Int_t GetMaximum() const;	virtual Int_t GetMaximum() const;
	Int_t GetNdata() const { return fNdata; }	Int_t GetNdata() const { return fNdata; }
	Int_t GetType() const { return fType; }	Int_t GetType() const { return fType; }
	Int_t GetStreamerType() const { return fStreamerType; }	Int_t GetStreamerType() const { return fStreamerType; }
	virtual TClass *GetTargetClass() { return fTargetClass; }	virtual TClass *GetTargetClass() { return fTargetClass; }
	virtual const char *GetTypeName() const;	virtual const char *GetTypeName() const;

	Double_t GetValue(Int_t i, Int_t len, Bool_t subarr = kF	Double_t GetValue(Int_t i, Int_t len, Bool_t subarr = kF
	ALSE) const;	ALSE) const { return GetTypedValue<Double_t>(i, len, subarr); }
		template<typename T > T GetTypedValue(Int_t i, Int_t len, Bool_t subarr
		= kFALSE) const;
	virtual void *GetValuePointer() const;	virtual void *GetValuePointer() const;
	Int_t GetClassVersion() { return fClassVersion; }	Int_t GetClassVersion() { return fClassVersion; }
	Bool_t IsBranchFolder() const { return TestBit(kBranch Folder); }	Bool_t IsBranchFolder() const { return TestBit(kBranch Folder); }
	Bool_t IsFolder() const;	Bool_t IsFolder() const;
	virtual Bool_t IsObjectOwner() const { return TestBit(kDeleteO bject); }	virtual Bool_t IsObjectOwner() const { return TestBit(kDeleteO bject); }
	virtual Bool_t Notify() { if (fAddress) { ResetAddress(); } re turn 1; }	virtual Bool_t Notify() { if (fAddress) { ResetAddress(); } re turn 1; }
	virtual void Print(Option_t* option = "") const;	virtual void Print(Option_t* option = "") const;
	void PrintValue(Int_t i) const;	void PrintValue(Int_t i) const;
	virtual void Reset(Option_t* option = "");	virtual void Reset(Option_t* option = "");
	virtual void ResetAfterMerge(TFileMergeInfo *);	virtual void ResetAfterMerge(TFileMergeInfo *);

End of changes. 3 change blocks.
	2 lines changed or deleted	6 lines changed or added

	TEfficiency.h	TEfficiency.h

	skipping to change at line 77	skipping to change at line 77

	enum{	enum{
	kIsBayesian = BIT(14), //bayesian statistics are used	kIsBayesian = BIT(14), //bayesian statistics are used
	kPosteriorMode = BIT(15), //use posterior mean for best estimate (Bayesian statistics)	kPosteriorMode = BIT(15), //use posterior mean for best estimate (Bayesian statistics)
	kShortestInterval = BIT(16), // use shortest interval	kShortestInterval = BIT(16), // use shortest interval
	kUseBinPrior = BIT(17), // use a different prior for each bin	kUseBinPrior = BIT(17), // use a different prior for each bin
	kUseWeights = BIT(18) // use weights	kUseWeights = BIT(18) // use weights
	};	};

	void Build(const char* name,const char* title);	void Build(const char* name,const char* title);

		void FillGraph(TGraphAsymmErrors * graph, Option_t * opt) co
		nst;
		void FillHistogram(TH2 * h2) const;

	public:	public:
	TEfficiency();	TEfficiency();
	TEfficiency(const TH1& passed,const TH1& total);	TEfficiency(const TH1& passed,const TH1& total);
	TEfficiency(const char* name,const char* title,Int_t nbins,	TEfficiency(const char* name,const char* title,Int_t nbins,
	const Double_t* xbins);	const Double_t* xbins);
	TEfficiency(const char* name,const char* title,Int_t nbins,Double_t x low,	TEfficiency(const char* name,const char* title,Int_t nbins,Double_t x low,
	Double_t xup);	Double_t xup);
	TEfficiency(const char* name,const char* title,Int_t nbinsx,	TEfficiency(const char* name,const char* title,Int_t nbinsx,
	Double_t xlow,Double_t xup,Int_t nbinsy,Double_t ylow,	Double_t xlow,Double_t xup,Int_t nbinsy,Double_t ylow,

	skipping to change at line 100	skipping to change at line 102
	TEfficiency(const char* name,const char* title,Int_t nbinsx,	TEfficiency(const char* name,const char* title,Int_t nbinsx,
	Double_t xlow,Double_t xup,Int_t nbinsy,Double_t ylow,	Double_t xlow,Double_t xup,Int_t nbinsy,Double_t ylow,
	Double_t yup,Int_t nbinsz,Double_t zlow,Double_t zup);	Double_t yup,Int_t nbinsz,Double_t zlow,Double_t zup);
	TEfficiency(const char* name,const char* title,Int_t nbinsx,	TEfficiency(const char* name,const char* title,Int_t nbinsx,
	const Double_t* xbins,Int_t nbinsy,const Double_t* ybins,	const Double_t* xbins,Int_t nbinsy,const Double_t* ybins,
	Int_t nbinsz,const Double_t* zbins);	Int_t nbinsz,const Double_t* zbins);
	TEfficiency(const TEfficiency& heff);	TEfficiency(const TEfficiency& heff);
	~TEfficiency();	~TEfficiency();

	void Add(const TEfficiency& rEff) {*this += rEff;}	void Add(const TEfficiency& rEff) {*this += rEff;}

		TGraphAsymmErrors* CreateGraph(Option_t * opt = "") const;
		TH2* CreateHistogram(Option_t * opt = "") const;
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
	void Draw(Option_t* opt = "");	void Draw(Option_t* opt = "");
	virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);	virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
	void Fill(Bool_t bPassed,Double_t x,Double_t y=0,Double_t z= 0);	void Fill(Bool_t bPassed,Double_t x,Double_t y=0,Double_t z= 0);
	void FillWeighted(Bool_t bPassed,Double_t weight,Double_t x, Double_t y=0,Double_t z=0);	void FillWeighted(Bool_t bPassed,Double_t weight,Double_t x, Double_t y=0,Double_t z=0);
	Int_t FindFixBin(Double_t x,Double_t y=0,Double_t z=0) const;	Int_t FindFixBin(Double_t x,Double_t y=0,Double_t z=0) const;
	Int_t Fit(TF1* f1,Option_t* opt="");	Int_t Fit(TF1* f1,Option_t* opt="");
	// use trick of -1 to return global parameters	// use trick of -1 to return global parameters
	Double_t GetBetaAlpha(Int_t bin = -1) const {return (fBeta_bin_p arams.size() > (UInt_t)bin) ? fBeta_bin_params[bin].first : fBeta_alpha;}	Double_t GetBetaAlpha(Int_t bin = -1) const {return (fBeta_bin_p arams.size() > (UInt_t)bin) ? fBeta_bin_params[bin].first : fBeta_alpha;}
	Double_t GetBetaBeta(Int_t bin = -1) const {return (fBeta_bin_p arams.size() > (UInt_t)bin) ? fBeta_bin_params[bin].second : fBeta_beta;}	Double_t GetBetaBeta(Int_t bin = -1) const {return (fBeta_bin_p arams.size() > (UInt_t)bin) ? fBeta_bin_params[bin].second : fBeta_beta;}

	skipping to change at line 144	skipping to change at line 148
	void SetConfidenceLevel(Double_t level);	void SetConfidenceLevel(Double_t level);
	void SetDirectory(TDirectory* dir);	void SetDirectory(TDirectory* dir);
	void SetName(const char* name);	void SetName(const char* name);
	Bool_t SetPassedEvents(Int_t bin,Int_t events);	Bool_t SetPassedEvents(Int_t bin,Int_t events);
	Bool_t SetPassedHistogram(const TH1& rPassed,Option_t* opt);	Bool_t SetPassedHistogram(const TH1& rPassed,Option_t* opt);
	void SetPosteriorMode(Bool_t on = true) { SetBit(kPosteriorM ode,on); SetShortestInterval(on); }	void SetPosteriorMode(Bool_t on = true) { SetBit(kPosteriorM ode,on); SetShortestInterval(on); }
	void SetPosteriorAverage(Bool_t on = true) { SetBit(kPosteri orMode,!on); }	void SetPosteriorAverage(Bool_t on = true) { SetBit(kPosteri orMode,!on); }
	void SetShortestInterval(Bool_t on = true) { SetBit(kShortes tInterval,on); }	void SetShortestInterval(Bool_t on = true) { SetBit(kShortes tInterval,on); }
	void SetCentralInterval(Bool_t on = true) { SetBit(kShortest Interval,!on); }	void SetCentralInterval(Bool_t on = true) { SetBit(kShortest Interval,!on); }
	void SetStatisticOption(EStatOption option);	void SetStatisticOption(EStatOption option);

		Bool_t SetBins(Int_t nx, Double_t xmin, Double_t xmax);
		Bool_t SetBins(Int_t nx, const Double_t *xBins);
		Bool_t SetBins(Int_t nx, Double_t xmin, Double_t xmax, Int_t n
		y, Double_t ymin, Double_t ymax);
		Bool_t SetBins(Int_t nx, const Double_t *xBins, Int_t ny, cons
		t Double_t *yBins);
		Bool_t SetBins(Int_t nx, Double_t xmin, Double_t xmax, Int_t n
		y, Double_t ymin, Double_t ymax,
		Int_t nz, Double_t zmin, Double_t zmax);
		Bool_t SetBins(Int_t nx, const Double_t *xBins, Int_t ny, cons
		t Double_t * yBins, Int_t nz,
		const Double_t *zBins);

	void SetTitle(const char* title);	void SetTitle(const char* title);
	Bool_t SetTotalEvents(Int_t bin,Int_t events);	Bool_t SetTotalEvents(Int_t bin,Int_t events);
	Bool_t SetTotalHistogram(const TH1& rTotal,Option_t* opt);	Bool_t SetTotalHistogram(const TH1& rTotal,Option_t* opt);
	void SetUseWeightedEvents();	void SetUseWeightedEvents();
	void SetWeight(Double_t weight);	void SetWeight(Double_t weight);
	Bool_t UsesBayesianStat() const {return TestBit(kIsBayesian);}	Bool_t UsesBayesianStat() const {return TestBit(kIsBayesian);}
	Bool_t UsesPosteriorMode() const {return TestBit(kPosteriorM ode) && TestBit(kIsBayesian);}	Bool_t UsesPosteriorMode() const {return TestBit(kPosteriorM ode) && TestBit(kIsBayesian);}
	Bool_t UsesShortestInterval() const {return TestBit(kShortes tInterval) && TestBit(kIsBayesian);}	Bool_t UsesShortestInterval() const {return TestBit(kShortes tInterval) && TestBit(kIsBayesian);}
	Bool_t UsesPosteriorAverage() const {return !UsesPosteriorMo de();}	Bool_t UsesPosteriorAverage() const {return !UsesPosteriorMo de();}
	Bool_t UsesCentralInterval() const {return !UsesShortestInte rval();}	Bool_t UsesCentralInterval() const {return !UsesShortestInte rval();}

End of changes. 3 change blocks.
	0 lines changed or deleted	18 lines changed or added

	TFormLeafInfoReference.h	TFormLeafInfoReference.h

	skipping to change at line 83	skipping to change at line 83
	virtual void GetLocalValuePointer( TLeaf from, Int_t instance = 0);	virtual void GetLocalValuePointer( TLeaf from, Int_t instance = 0);
	// Return the address of the local value	// Return the address of the local value
	virtual void GetLocalValuePointer(char from, Int_t instance = 0);	virtual void GetLocalValuePointer(char from, Int_t instance = 0);
	// Return true if any of underlying data has a array size counter	// Return true if any of underlying data has a array size counter
	virtual Bool_t HasCounter() const;	virtual Bool_t HasCounter() const;
	// Return the size of the underlying array for the current entry in the TTree.	// Return the size of the underlying array for the current entry in the TTree.
	virtual Int_t ReadCounterValue(char *where);	virtual Int_t ReadCounterValue(char *where);
	// Return the current size of the array container	// Return the current size of the array container
	virtual Int_t GetCounterValue(TLeaf* leaf);	virtual Int_t GetCounterValue(TLeaf* leaf);


	// Access value of referenced object	// Access value of referenced object (macro from TFormLeafInfo.g)
	virtual Double_t GetValue(TLeaf *leaf, Int_t instance);	DECLARE_GETVAL;
	// Read value of referenced object	// Read value of referenced object

	virtual Double_t ReadValue(char *where, Int_t instance = 0);	DECLARE_READVAL;
	// TFormLeafInfo overload: Update (and propagate) cached information	// TFormLeafInfo overload: Update (and propagate) cached information
	virtual Bool_t Update();	virtual Bool_t Update();
	};	};
	#endif /* ROOT_TFormLeafInfoReference */	#endif /* ROOT_TFormLeafInfoReference */

End of changes. 2 change blocks.
	3 lines changed or deleted	3 lines changed or added

	TGeoManager.h	TGeoManager.h

	skipping to change at line 432	skipping to change at line 432
	virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);	virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
	static Int_t Parse(const char* expr, TString &expr1, TString & expr2, TString &expr3);	static Int_t Parse(const char* expr, TString &expr1, TString & expr2, TString &expr3);
	Int_t ReplaceVolume(TGeoVolume vorig, TGeoVolume vnew );	Int_t ReplaceVolume(TGeoVolume vorig, TGeoVolume vnew );
	Int_t TransformVolumeToAssembly(const char *vname);	Int_t TransformVolumeToAssembly(const char *vname);
	UChar_t *GetBits() {return fBits;}	UChar_t *GetBits() {return fBits;}
	virtual Int_t GetByteCount(Option_t *option=0);	virtual Int_t GetByteCount(Option_t *option=0);
	void SetAllIndex();	void SetAllIndex();
	static Int_t GetMaxDaughters();	static Int_t GetMaxDaughters();
	static Int_t GetMaxLevels();	static Int_t GetMaxLevels();
	static Int_t GetMaxXtruVert();	static Int_t GetMaxXtruVert();

	Int_t GetMaxThreads() const {return fMaxThreads;}	Int_t GetMaxThreads() const {return fMaxThreads-1;}
	void SetMaxThreads(Int_t nthreads);	void SetMaxThreads(Int_t nthreads);
	void SetMultiThread(Bool_t flag=kTRUE) {fMultiThread = flag;}	void SetMultiThread(Bool_t flag=kTRUE) {fMultiThread = flag;}
	Bool_t IsMultiThread() const {return fMultiThread;}	Bool_t IsMultiThread() const {return fMultiThread;}
	static void SetNavigatorsLock(Bool_t flag);	static void SetNavigatorsLock(Bool_t flag);
	static Int_t ThreadId();	static Int_t ThreadId();
	static Int_t GetNumThreads();	static Int_t GetNumThreads();
	static void ClearThreadsMap();	static void ClearThreadsMap();
	void ClearThreadData() const;	void ClearThreadData() const;
	void CreateThreadData() const;	void CreateThreadData() const;


End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	TGeoVolume.h	TGeoVolume.h

	skipping to change at line 70	skipping to change at line 70
	class TGeoVolume : public TNamed,	class TGeoVolume : public TNamed,
	public TGeoAtt,	public TGeoAtt,
	public TAttLine,	public TAttLine,
	public TAttFill,	public TAttFill,
	public TAtt3D	public TAtt3D
	{	{
	protected :	protected :
	TObjArray *fNodes; // array of nodes inside this volume	TObjArray *fNodes; // array of nodes inside this volume
	TGeoShape *fShape; // shape	TGeoShape *fShape; // shape
	TGeoMedium *fMedium; // tracking medium	TGeoMedium *fMedium; // tracking medium

		static TGeoMedium *fgDummyMedium; //! dummy medium
	TGeoPatternFinder *fFinder; // finder object for divisions	TGeoPatternFinder *fFinder; // finder object for divisions
	TGeoVoxelFinder *fVoxels; // finder object for bounding boxes	TGeoVoxelFinder *fVoxels; // finder object for bounding boxes
	TGeoManager *fGeoManager; //! pointer to TGeoManager owning th is volume	TGeoManager *fGeoManager; //! pointer to TGeoManager owning th is volume

	TObject *fField; //! just a hook for now	TObject *fField; //! just a hook for now
	TString fOption; //! option - if any	TString fOption; //! option - if any
	Int_t fNumber; // volume serial number in the list of volumes	Int_t fNumber; // volume serial number in the list of volumes
	Int_t fNtotal; // total number of physical nodes	Int_t fNtotal; // total number of physical nodes
	TGeoExtension *fUserExtension; //! Transient user-defined extension to volumes	TGeoExtension *fUserExtension; //! Transient user-defined extension to volumes
	TGeoExtension *fFWExtension; //! Transient framework-defined exte nsion to volumes	TGeoExtension *fFWExtension; //! Transient framework-defined exte nsion to volumes

	skipping to change at line 122	skipping to change at line 123
	void ClearNodes() {fNodes = 0;}	void ClearNodes() {fNodes = 0;}
	void ClearShape();	void ClearShape();
	void CleanAll();	void CleanAll();
	virtual TGeoVolume *CloneVolume() const;	virtual TGeoVolume *CloneVolume() const;
	void CloneNodesAndConnect(TGeoVolume *newmother) const;	void CloneNodesAndConnect(TGeoVolume *newmother) const;
	void CheckGeometry(Int_t nrays=1, Double_t startx=0, Double_t starty=0, Double_t startz=0) const;	void CheckGeometry(Int_t nrays=1, Double_t startx=0, Double_t starty=0, Double_t startz=0) const;
	void CheckOverlaps(Double_t ovlp=0.1, Option_t option="") co nst; // MENU*	void CheckOverlaps(Double_t ovlp=0.1, Option_t option="") co nst; // MENU*
	void CheckShape(Int_t testNo, Int_t nsamples=10000, Option_t option=""); // MENU*	void CheckShape(Int_t testNo, Int_t nsamples=10000, Option_t option=""); // MENU*
	Int_t CountNodes(Int_t nlevels=1000, Int_t option=0);	Int_t CountNodes(Int_t nlevels=1000, Int_t option=0);
	Bool_t Contains(const Double_t *point) const {return fShape->Co ntains(point);}	Bool_t Contains(const Double_t *point) const {return fShape->Co ntains(point);}

		static void CreateDummyMedium();
		static TGeoMedium *DummyMedium();
	virtual Bool_t IsAssembly() const;	virtual Bool_t IsAssembly() const;
	virtual Bool_t IsFolder() const;	virtual Bool_t IsFolder() const;
	Bool_t IsRunTime() const {return fShape->IsRunTimeShape();}	Bool_t IsRunTime() const {return fShape->IsRunTimeShape();}
	virtual Bool_t IsVolumeMulti() const {return kFALSE;}	virtual Bool_t IsVolumeMulti() const {return kFALSE;}
	virtual void AddNode(const TGeoVolume vol, Int_t copy_no, TGeoMatrix mat=0, Option_t *option=""); // most general case	virtual void AddNode(const TGeoVolume vol, Int_t copy_no, TGeoMatrix mat=0, Option_t *option=""); // most general case
	void AddNodeOffset(const TGeoVolume vol, Int_t copy_no, Doub le_t offset=0, Option_t option="");	void AddNodeOffset(const TGeoVolume vol, Int_t copy_no, Doub le_t offset=0, Option_t option="");
	virtual void AddNodeOverlap(const TGeoVolume vol, Int_t copy_no, TGe oMatrix mat=0, Option_t *option="");	virtual void AddNodeOverlap(const TGeoVolume vol, Int_t copy_no, TGe oMatrix mat=0, Option_t *option="");

	virtual TGeoVolume Divide(const char divname, Int_t iaxis, Int_t ndiv, Double_t start, Double_t step, Int_t numed=0, Option_t *option="");	virtual TGeoVolume Divide(const char divname, Int_t iaxis, Int_t ndiv, Double_t start, Double_t step, Int_t numed=0, Option_t *option="");
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);

	skipping to change at line 177	skipping to change at line 180
	TGeoNode FindNode(const char name) const;	TGeoNode FindNode(const char name) const;
	void FindOverlaps() const;	void FindOverlaps() const;
	Bool_t FindMatrixOfDaughterVolume(TGeoVolume *vol) const;	Bool_t FindMatrixOfDaughterVolume(TGeoVolume *vol) const;
	virtual Int_t GetCurrentNodeIndex() const {return -1;}	virtual Int_t GetCurrentNodeIndex() const {return -1;}
	virtual Int_t GetNextNodeIndex() const {return -1;}	virtual Int_t GetNextNodeIndex() const {return -1;}
	TObjArray *GetNodes() {return fNodes;}	TObjArray *GetNodes() {return fNodes;}
	Int_t GetNdaughters() const;	Int_t GetNdaughters() const;
	Int_t GetNtotal() const {return fNtotal;}	Int_t GetNtotal() const {return fNtotal;}
	virtual Int_t GetByteCount() const;	virtual Int_t GetByteCount() const;
	TGeoManager *GetGeoManager() const {return fGeoManager;}	TGeoManager *GetGeoManager() const {return fGeoManager;}

	TGeoMaterial *GetMaterial() const {return fMedium->GetMa	TGeoMaterial *GetMaterial() const {return GetMedium()->G
	terial();}	etMaterial();}
	TGeoMedium *GetMedium() const {return fMedium;}	TGeoMedium *GetMedium() const {return (fMedium)?fMed
		ium:DummyMedium();}
	TObject *GetField() const {return fField;}	TObject *GetField() const {return fField;}
	TGeoPatternFinder *GetFinder() const {return fFinder;}	TGeoPatternFinder *GetFinder() const {return fFinder;}
	TGeoVoxelFinder *GetVoxels() const;	TGeoVoxelFinder *GetVoxels() const;
	const char *GetIconName() const {return fShape->GetNam e();}	const char *GetIconName() const {return fShape->GetNam e();}
	Int_t GetIndex(const TGeoNode *node) const;	Int_t GetIndex(const TGeoNode *node) const;
	TGeoNode GetNode(const char name) const;	TGeoNode GetNode(const char name) const;
	TGeoNode GetNode(Int_t i) const {return (TGeoNode)fNodes->Unchec kedAt(i);}	TGeoNode GetNode(Int_t i) const {return (TGeoNode)fNodes->Unchec kedAt(i);}
	Int_t GetNodeIndex(const TGeoNode node, Int_t check_list, In t_t ncheck) const;	Int_t GetNodeIndex(const TGeoNode node, Int_t check_list, In t_t ncheck) const;
	Int_t GetNumber() const {return fNumber;}	Int_t GetNumber() const {return fNumber;}
	virtual char *GetObjectInfo(Int_t px, Int_t py) const;	virtual char *GetObjectInfo(Int_t px, Int_t py) const;

End of changes. 3 change blocks.
	3 lines changed or deleted	7 lines changed or added

	TH1.h	TH1.h

	skipping to change at line 132	skipping to change at line 132
	Int_t AxisChoice(Option_t *axis) const;	Int_t AxisChoice(Option_t *axis) const;
	void Build();	void Build();

	TH1& operator=(const TH1&); // Not implemented	TH1& operator=(const TH1&); // Not implemented

	protected:	protected:
	TH1();	TH1();
	TH1(const char name,const char title,Int_t nbinsx,Double_t xlow,Double _t xup);	TH1(const char name,const char title,Int_t nbinsx,Double_t xlow,Double _t xup);
	TH1(const char name,const char title,Int_t nbinsx,const Float_t *xbins );	TH1(const char name,const char title,Int_t nbinsx,const Float_t *xbins );
	TH1(const char name,const char title,Int_t nbinsx,const Double_t *xbin s);	TH1(const char name,const char title,Int_t nbinsx,const Double_t *xbin s);

	virtual void Copy(TObject &hnew) const;
	virtual Int_t BufferFill(Double_t x, Double_t w);	virtual Int_t BufferFill(Double_t x, Double_t w);
	virtual Bool_t FindNewAxisLimits(const TAxis* axis, const Double_t poi nt, Double_t& newMin, Double_t &newMax);	virtual Bool_t FindNewAxisLimits(const TAxis* axis, const Double_t poi nt, Double_t& newMin, Double_t &newMax);
	virtual void SavePrimitiveHelp(ostream &out, const char hname, Opti on_t option = "");	virtual void SavePrimitiveHelp(ostream &out, const char hname, Opti on_t option = "");
	static Bool_t RecomputeAxisLimits(TAxis& destAxis, const TAxis& anAxi s);	static Bool_t RecomputeAxisLimits(TAxis& destAxis, const TAxis& anAxi s);
	static Bool_t SameLimitsAndNBins(const TAxis& axis1, const TAxis& axi s2);	static Bool_t SameLimitsAndNBins(const TAxis& axis1, const TAxis& axi s2);

	virtual Double_t DoIntegral(Int_t ix1, Int_t ix2, Int_t iy1, Int_t iy2, Int_t iz1, Int_t iz2, Double_t & err,	virtual Double_t DoIntegral(Int_t ix1, Int_t ix2, Int_t iy1, Int_t iy2, Int_t iz1, Int_t iz2, Double_t & err,
	Option_t * opt, Bool_t doerr = kFALSE) const ;	Option_t * opt, Bool_t doerr = kFALSE) const ;

	static bool CheckAxisLimits(const TAxis* a1, const TAxis* a2);	static bool CheckAxisLimits(const TAxis* a1, const TAxis* a2);

	skipping to change at line 185	skipping to change at line 184
	virtual Bool_t Add(const TH1 h, const TH1 h2, Double_t c1=1, Double_ t c2=1); // MENU	virtual Bool_t Add(const TH1 h, const TH1 h2, Double_t c1=1, Double_ t c2=1); // MENU
	virtual void AddBinContent(Int_t bin);	virtual void AddBinContent(Int_t bin);
	virtual void AddBinContent(Int_t bin, Double_t w);	virtual void AddBinContent(Int_t bin, Double_t w);
	static void AddDirectory(Bool_t add=kTRUE);	static void AddDirectory(Bool_t add=kTRUE);
	static Bool_t AddDirectoryStatus();	static Bool_t AddDirectoryStatus();
	virtual void Browse(TBrowser *b);	virtual void Browse(TBrowser *b);
	virtual Double_t Chi2Test(const TH1* h2, Option_t option = "UU", Double _t res = 0) const;	virtual Double_t Chi2Test(const TH1* h2, Option_t option = "UU", Double _t res = 0) const;
	virtual Double_t Chi2TestX(const TH1* h2, Double_t &chi2, Int_t &ndf, In t_t &igood,Option_t option = "UU", Double_t res = 0) const;	virtual Double_t Chi2TestX(const TH1* h2, Double_t &chi2, Int_t &ndf, In t_t &igood,Option_t option = "UU", Double_t res = 0) const;

	virtual Double_t Chisquare(TF1 * f1, Option_t *option = "") const;	virtual Double_t Chisquare(TF1 * f1, Option_t *option = "") const;

	virtual Double_t ComputeIntegral();	virtual Double_t ComputeIntegral(Bool_t onlyPositive = false);
		virtual void Copy(TObject &hnew) const;
	virtual void DirectoryAutoAdd(TDirectory *);	virtual void DirectoryAutoAdd(TDirectory *);
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
	virtual Bool_t Divide(TF1 *f1, Double_t c1=1);	virtual Bool_t Divide(TF1 *f1, Double_t c1=1);
	virtual Bool_t Divide(const TH1 *h1);	virtual Bool_t Divide(const TH1 *h1);
	virtual Bool_t Divide(const TH1 h1, const TH1 h2, Double_t c1=1, Dou ble_t c2=1, Option_t option=""); // MENU*	virtual Bool_t Divide(const TH1 h1, const TH1 h2, Double_t c1=1, Dou ble_t c2=1, Option_t option=""); // MENU*
	virtual void Draw(Option_t *option="");	virtual void Draw(Option_t *option="");
	virtual TH1 DrawCopy(Option_t option="") const;	virtual TH1 DrawCopy(Option_t option="") const;
	virtual TH1 DrawNormalized(Option_t option="", Double_t norm=1) co nst;	virtual TH1 DrawNormalized(Option_t option="", Double_t norm=1) co nst;
	virtual void DrawPanel(); // MENU	virtual void DrawPanel(); // MENU
	virtual Int_t BufferEmpty(Int_t action=0);	virtual Int_t BufferEmpty(Int_t action=0);

	skipping to change at line 242	skipping to change at line 242
	virtual Float_t GetTitleSize(Option_t *axis="X") const;	virtual Float_t GetTitleSize(Option_t *axis="X") const;
	virtual Float_t GetTickLength(Option_t *axis="X") const;	virtual Float_t GetTickLength(Option_t *axis="X") const;
	virtual Float_t GetBarOffset() const {return Float_t(0.001*Float_t(fBar Offset));}	virtual Float_t GetBarOffset() const {return Float_t(0.001*Float_t(fBar Offset));}
	virtual Float_t GetBarWidth() const {return Float_t(0.001*Float_t(fBar Width));}	virtual Float_t GetBarWidth() const {return Float_t(0.001*Float_t(fBar Width));}
	virtual Int_t GetContour(Double_t *levels=0);	virtual Int_t GetContour(Double_t *levels=0);
	virtual Double_t GetContourLevel(Int_t level) const;	virtual Double_t GetContourLevel(Int_t level) const;
	virtual Double_t GetContourLevelPad(Int_t level) const;	virtual Double_t GetContourLevelPad(Int_t level) const;

	virtual Int_t GetBin(Int_t binx, Int_t biny=0, Int_t binz=0) const;	virtual Int_t GetBin(Int_t binx, Int_t biny=0, Int_t binz=0) const;
	virtual void GetBinXYZ(Int_t binglobal, Int_t &binx, Int_t &biny, In t_t &binz) const;	virtual void GetBinXYZ(Int_t binglobal, Int_t &binx, Int_t &biny, In t_t &binz) const;

	virtual Double_t GetBinCenter(Int_t bin) const {return fXaxis.GetBinCent er(bin);}	virtual Double_t GetBinCenter(Int_t bin) const;
	virtual Double_t GetBinContent(Int_t bin) const;	virtual Double_t GetBinContent(Int_t bin) const;
	virtual Double_t GetBinContent(Int_t binx, Int_t biny) const;	virtual Double_t GetBinContent(Int_t binx, Int_t biny) const;
	virtual Double_t GetBinContent(Int_t binx, Int_t biny, Int_t binz) const ;	virtual Double_t GetBinContent(Int_t binx, Int_t biny, Int_t binz) const ;
	virtual Double_t GetBinError(Int_t bin) const;	virtual Double_t GetBinError(Int_t bin) const;
	virtual Double_t GetBinError(Int_t binx, Int_t biny) const;	virtual Double_t GetBinError(Int_t binx, Int_t biny) const;
	virtual Double_t GetBinError(Int_t binx, Int_t biny, Int_t binz) const;	virtual Double_t GetBinError(Int_t binx, Int_t biny, Int_t binz) const;
	virtual Double_t GetBinErrorLow(Int_t bin) const;	virtual Double_t GetBinErrorLow(Int_t bin) const;
	virtual Double_t GetBinErrorUp(Int_t bin) const;	virtual Double_t GetBinErrorUp(Int_t bin) const;
	virtual EBinErrorOpt GetBinErrorOption() const { return fBinStatErrOpt; }	virtual EBinErrorOpt GetBinErrorOption() const { return fBinStatErrOpt; }

	virtual Double_t GetBinLowEdge(Int_t bin) const {return fXaxis.GetBinLow	virtual Double_t GetBinLowEdge(Int_t bin) const;
	Edge(bin);}	virtual Double_t GetBinWidth(Int_t bin) const;
	virtual Double_t GetBinWidth(Int_t bin) const {return fXaxis.GetBinWidth
	(bin);}
	virtual Double_t GetBinWithContent(Double_t c, Int_t &binx, Int_t firstx =0, Int_t lastx=0,Double_t maxdiff=0) const;	virtual Double_t GetBinWithContent(Double_t c, Int_t &binx, Int_t firstx =0, Int_t lastx=0,Double_t maxdiff=0) const;
	virtual Double_t GetCellContent(Int_t binx, Int_t biny) const;	virtual Double_t GetCellContent(Int_t binx, Int_t biny) const;
	virtual Double_t GetCellError(Int_t binx, Int_t biny) const;	virtual Double_t GetCellError(Int_t binx, Int_t biny) const;

	virtual void GetCenter(Double_t *center) const {fXaxis.GetCenter(cen ter);}	virtual void GetCenter(Double_t *center) const;
	static Bool_t GetDefaultSumw2();	static Bool_t GetDefaultSumw2();
	TDirectory *GetDirectory() const {return fDirectory;}	TDirectory *GetDirectory() const {return fDirectory;}
	virtual Double_t GetEntries() const;	virtual Double_t GetEntries() const;
	virtual Double_t GetEffectiveEntries() const;	virtual Double_t GetEffectiveEntries() const;
	virtual TF1 GetFunction(const char name) const;	virtual TF1 GetFunction(const char name) const;
	virtual Int_t GetDimension() const { return fDimension; }	virtual Int_t GetDimension() const { return fDimension; }
	virtual Double_t GetKurtosis(Int_t axis=1) const;	virtual Double_t GetKurtosis(Int_t axis=1) const;

	virtual void GetLowEdge(Double_t *edge) const {fXaxis.GetLowEdge(edg e);}	virtual void GetLowEdge(Double_t *edge) const;
	virtual Double_t GetMaximum(Double_t maxval=FLT_MAX) const;	virtual Double_t GetMaximum(Double_t maxval=FLT_MAX) const;
	virtual Int_t GetMaximumBin() const;	virtual Int_t GetMaximumBin() const;
	virtual Int_t GetMaximumBin(Int_t &locmax, Int_t &locmay, Int_t &locm az) const;	virtual Int_t GetMaximumBin(Int_t &locmax, Int_t &locmay, Int_t &locm az) const;
	virtual Double_t GetMaximumStored() const {return fMaximum;}	virtual Double_t GetMaximumStored() const {return fMaximum;}
	virtual Double_t GetMinimum(Double_t minval=-FLT_MAX) const;	virtual Double_t GetMinimum(Double_t minval=-FLT_MAX) const;
	virtual Int_t GetMinimumBin() const;	virtual Int_t GetMinimumBin() const;
	virtual Int_t GetMinimumBin(Int_t &locmix, Int_t &locmiy, Int_t &locm iz) const;	virtual Int_t GetMinimumBin(Int_t &locmix, Int_t &locmiy, Int_t &locm iz) const;
	virtual Double_t GetMinimumStored() const {return fMinimum;}	virtual Double_t GetMinimumStored() const {return fMinimum;}
	virtual Double_t GetMean(Int_t axis=1) const;	virtual Double_t GetMean(Int_t axis=1) const;
	virtual Double_t GetMeanError(Int_t axis=1) const;	virtual Double_t GetMeanError(Int_t axis=1) const;

End of changes. 6 change blocks.
	9 lines changed or deleted	7 lines changed or added

	THistPainter.h	THistPainter.h

	skipping to change at line 78	skipping to change at line 78
	virtual Bool_t IsInside(Int_t x, Int_t y);	virtual Bool_t IsInside(Int_t x, Int_t y);
	virtual Bool_t IsInside(Double_t x, Double_t y);	virtual Bool_t IsInside(Double_t x, Double_t y);
	virtual Int_t MakeChopt(Option_t *option);	virtual Int_t MakeChopt(Option_t *option);
	virtual Int_t MakeCuts(char *cutsopt);	virtual Int_t MakeCuts(char *cutsopt);
	virtual void Paint(Option_t *option="");	virtual void Paint(Option_t *option="");
	virtual void PaintArrows(Option_t *option);	virtual void PaintArrows(Option_t *option);
	virtual void PaintAxis(Bool_t drawGridOnly=kFALSE);	virtual void PaintAxis(Bool_t drawGridOnly=kFALSE);
	virtual void PaintBar(Option_t *option);	virtual void PaintBar(Option_t *option);
	virtual void PaintBarH(Option_t *option);	virtual void PaintBarH(Option_t *option);
	virtual void PaintBoxes(Option_t *option);	virtual void PaintBoxes(Option_t *option);

		virtual void PaintCandlePlot(Option_t *option);
	virtual void PaintColorLevels(Option_t *option);	virtual void PaintColorLevels(Option_t *option);
	virtual void PaintTH2PolyBins(Option_t *option);	virtual void PaintTH2PolyBins(Option_t *option);
	virtual void PaintTH2PolyColorLevels(Option_t *option);	virtual void PaintTH2PolyColorLevels(Option_t *option);
	virtual void PaintTH2PolyScatterPlot(Option_t *option);	virtual void PaintTH2PolyScatterPlot(Option_t *option);
	virtual void PaintTH2PolyText(Option_t *option);	virtual void PaintTH2PolyText(Option_t *option);
	virtual void PaintContour(Option_t *option);	virtual void PaintContour(Option_t *option);
	virtual Int_t PaintContourLine(Double_t elev1, Int_t icont1, Double _t x1, Double_t y1,	virtual Int_t PaintContourLine(Double_t elev1, Int_t icont1, Double _t x1, Double_t y1,
	Double_t elev2, Int_t icont2, Double_t x2, Double _t y2,	Double_t elev2, Int_t icont2, Double_t x2, Double _t y2,
	Double_t xarr, Double_t yarr, Int_t itarr, Dou ble_t levels);	Double_t xarr, Double_t yarr, Int_t itarr, Dou ble_t levels);
	virtual void PaintErrors(Option_t *option);	virtual void PaintErrors(Option_t *option);

End of changes. 1 change blocks.
	0 lines changed or deleted	1 lines changed or added

	TMatrixT.h	TMatrixT.h

	skipping to change at line 51	skipping to change at line 51
	Element fDataStack[TMatrixTBase<Element>::kSizeMax]; //! data container	Element fDataStack[TMatrixTBase<Element>::kSizeMax]; //! data container
	Element *fElements; //[fNelems] elemen ts themselves	Element *fElements; //[fNelems] elemen ts themselves

	Element *New_m (Int_t size);	Element *New_m (Int_t size);
	void Delete_m(Int_t size,Element*&);	void Delete_m(Int_t size,Element*&);
	Int_t Memcpy_m(Element newp,const Element oldp,Int_t copySize,	Int_t Memcpy_m(Element newp,const Element oldp,Int_t copySize,
	Int_t newSize,Int_t oldSize);	Int_t newSize,Int_t oldSize);
	void Allocate(Int_t nrows,Int_t ncols,Int_t row_lwb = 0,Int_t col_lw b = 0,Int_t init = 0,	void Allocate(Int_t nrows,Int_t ncols,Int_t row_lwb = 0,Int_t col_lw b = 0,Int_t init = 0,
	Int_t /nr_nonzeros/ = -1);	Int_t /nr_nonzeros/ = -1);


		static Element & NaNValue();

	public:	public:

	enum {kWorkMax = 100};	enum {kWorkMax = 100};
	enum EMatrixCreatorsOp1 { kZero,kUnit,kTransposed,kInverted,kAtA };	enum EMatrixCreatorsOp1 { kZero,kUnit,kTransposed,kInverted,kAtA };
	enum EMatrixCreatorsOp2 { kMult,kTransposeMult,kInvMult,kMultTranspose,k Plus,kMinus };	enum EMatrixCreatorsOp2 { kMult,kTransposeMult,kInvMult,kMultTranspose,k Plus,kMinus };

	TMatrixT(): fDataStack(), fElements(0) { }	TMatrixT(): fDataStack(), fElements(0) { }
	TMatrixT(Int_t nrows,Int_t ncols);	TMatrixT(Int_t nrows,Int_t ncols);
	TMatrixT(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb);	TMatrixT(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb);
	TMatrixT(Int_t nrows,Int_t ncols,const Element data,Option_t option="" );	TMatrixT(Int_t nrows,Int_t ncols,const Element data,Option_t option="" );

	skipping to change at line 240	skipping to change at line 242
	return tmp;	return tmp;
	}	}

	template <class Element> inline Element TMatrixT<Element>::operator()(Int_t rown,Int_t coln) const	template <class Element> inline Element TMatrixT<Element>::operator()(Int_t rown,Int_t coln) const
	{	{
	R__ASSERT(this->IsValid());	R__ASSERT(this->IsValid());
	const Int_t arown = rown-this->fRowLwb;	const Int_t arown = rown-this->fRowLwb;
	const Int_t acoln = coln-this->fColLwb;	const Int_t acoln = coln-this->fColLwb;
	if (arown >= this->fNrows \|\| arown < 0) {	if (arown >= this->fNrows \|\| arown < 0) {
	Error("operator()","Request row(%d) outside matrix range of %d - %d", rown,this->fRowLwb,this->fRowLwb+this->fNrows);	Error("operator()","Request row(%d) outside matrix range of %d - %d", rown,this->fRowLwb,this->fRowLwb+this->fNrows);

	return fElements[0];	return NaNValue();
	}	}
	if (acoln >= this->fNcols \|\| acoln < 0) {	if (acoln >= this->fNcols \|\| acoln < 0) {
	Error("operator()","Request column(%d) outside matrix range of %d - % d",coln,this->fColLwb,this->fColLwb+this->fNcols);	Error("operator()","Request column(%d) outside matrix range of %d - % d",coln,this->fColLwb,this->fColLwb+this->fNcols);

	return fElements[0];	return NaNValue();

	}	}
	return (fElements[arown*this->fNcols+acoln]);	return (fElements[arown*this->fNcols+acoln]);
	}	}

	template <class Element> inline Element &TMatrixT<Element>::operator()(Int_ t rown,Int_t coln)	template <class Element> inline Element &TMatrixT<Element>::operator()(Int_ t rown,Int_t coln)
	{	{
	R__ASSERT(this->IsValid());	R__ASSERT(this->IsValid());
	const Int_t arown = rown-this->fRowLwb;	const Int_t arown = rown-this->fRowLwb;
	const Int_t acoln = coln-this->fColLwb;	const Int_t acoln = coln-this->fColLwb;
	if (arown >= this->fNrows \|\| arown < 0) {	if (arown >= this->fNrows \|\| arown < 0) {
	Error("operator()","Request row(%d) outside matrix range of %d - %d", rown,this->fRowLwb,this->fRowLwb+this->fNrows);	Error("operator()","Request row(%d) outside matrix range of %d - %d", rown,this->fRowLwb,this->fRowLwb+this->fNrows);

	return fElements[0];	return NaNValue();

	}	}
	if (acoln >= this->fNcols \|\| acoln < 0) {	if (acoln >= this->fNcols \|\| acoln < 0) {
	Error("operator()","Request column(%d) outside matrix range of %d - % d",coln,this->fColLwb,this->fColLwb+this->fNcols);	Error("operator()","Request column(%d) outside matrix range of %d - % d",coln,this->fColLwb,this->fColLwb+this->fNcols);

	return fElements[0];	return NaNValue();
	}	}
	return (fElements[arown*this->fNcols+acoln]);	return (fElements[arown*this->fNcols+acoln]);
	}	}

	template <class Element> TMatrixT<Element> operator+ (const TMatrixT <E lement> &source1,const TMatrixT <Element> &source2);	template <class Element> TMatrixT<Element> operator+ (const TMatrixT <E lement> &source1,const TMatrixT <Element> &source2);
	template <class Element> TMatrixT<Element> operator+ (const TMatrixT <E lement> &source1,const TMatrixTSym<Element> &source2);	template <class Element> TMatrixT<Element> operator+ (const TMatrixT <E lement> &source1,const TMatrixTSym<Element> &source2);
	template <class Element> TMatrixT<Element> operator+ (const TMatrixTSym<E lement> &source1,const TMatrixT <Element> &source2);	template <class Element> TMatrixT<Element> operator+ (const TMatrixTSym<E lement> &source1,const TMatrixT <Element> &source2);
	template <class Element> TMatrixT<Element> operator+ (const TMatrixT <E lement> &source , Element val );	template <class Element> TMatrixT<Element> operator+ (const TMatrixT <E lement> &source , Element val );
	template <class Element> TMatrixT<Element> operator+ ( Element val ,const TMatrixT <Element> &source );	template <class Element> TMatrixT<Element> operator+ ( Element val ,const TMatrixT <Element> &source );
	template <class Element> TMatrixT<Element> operator- (const TMatrixT <E lement> &source1,const TMatrixT <Element> &source2);	template <class Element> TMatrixT<Element> operator- (const TMatrixT <E lement> &source1,const TMatrixT <Element> &source2);

End of changes. 5 change blocks.
	4 lines changed or deleted	8 lines changed or added

	TStreamerInfo.h	TStreamerInfo.h

	skipping to change at line 115	skipping to change at line 115
	ULong_t *fVirtualInfoLoc; //![fNVirtualInfoLoc] Location of the pointer to the TStreamerInfo inside the object (when emulated)	ULong_t *fVirtualInfoLoc; //![fNVirtualInfoLoc] Location of the pointer to the TStreamerInfo inside the object (when emulated)
	ULong_t fLiveCount; //! Number of outstanding pointer to this StreamerInfo.	ULong_t fLiveCount; //! Number of outstanding pointer to this StreamerInfo.

	TStreamerInfoActions::TActionSequence *fReadObjectWise; //! List of read action resulting from the compilation.	TStreamerInfoActions::TActionSequence *fReadObjectWise; //! List of read action resulting from the compilation.
	TStreamerInfoActions::TActionSequence *fReadMemberWise; //! List of read action resulting from the compilation for use in member wise streamin g.	TStreamerInfoActions::TActionSequence *fReadMemberWise; //! List of read action resulting from the compilation for use in member wise streamin g.
	TStreamerInfoActions::TActionSequence *fWriteObjectWise; //! List of write action resulting from the compilation.	TStreamerInfoActions::TActionSequence *fWriteObjectWise; //! List of write action resulting from the compilation.
	TStreamerInfoActions::TActionSequence *fWriteMemberWise; //! List of write action resulting from the compilation for use in member wise streami ng.	TStreamerInfoActions::TActionSequence *fWriteMemberWise; //! List of write action resulting from the compilation for use in member wise streami ng.

	static Int_t fgCount; //Number of TStreamerInfo instance s	static Int_t fgCount; //Number of TStreamerInfo instance s
	static TStreamerElement *fgElement; //Pointer to current TStreamerElem ent	static TStreamerElement *fgElement; //Pointer to current TStreamerElem ent

	static Double_t GetValueAux(Int_t type, void *ladd, int k, Int_t len);	template <typename T> static T GetTypedValueAux(Int_t type, void *ladd, int k, Int_t len);
	static void PrintValueAux(char ladd, Int_t atype, TStreamerElemen t aElement, Int_t aleng, Int_t *count);	static void PrintValueAux(char ladd, Int_t atype, TStreamerElemen t aElement, Int_t aleng, Int_t *count);

	UInt_t GenerateIncludes(FILE fp, char inclist, const TList *extrainfos);	UInt_t GenerateIncludes(FILE fp, char inclist, const TList *extrainfos);
	void GenerateDeclaration(FILE fp, FILE sfp, const TList * subClasses, Bool_t top = kTRUE);	void GenerateDeclaration(FILE fp, FILE sfp, const TList * subClasses, Bool_t top = kTRUE);
	void InsertArtificialElements(const TObjArray *rules);	void InsertArtificialElements(const TObjArray *rules);
	void DestructorImpl(void* p, Bool_t dtorOnly);	void DestructorImpl(void* p, Bool_t dtorOnly);

	private:	private:
	TStreamerInfo(const TStreamerInfo&); // TStreamerInfo are cop iable. Not Implemented.	TStreamerInfo(const TStreamerInfo&); // TStreamerInfo are cop iable. Not Implemented.
	TStreamerInfo& operator=(const TStreamerInfo&); // TStreamerInfo are cop iable. Not Implemented.	TStreamerInfo& operator=(const TStreamerInfo&); // TStreamerInfo are cop iable. Not Implemented.

	skipping to change at line 220	skipping to change at line 220
	Int_t *GetNewTypes() const {return fNewType;}	Int_t *GetNewTypes() const {return fNewType;}
	Int_t GetOffset(const char *) const;	Int_t GetOffset(const char *) const;
	Int_t *GetOffsets() const {return fOffset;}	Int_t *GetOffsets() const {return fOffset;}
	Version_t GetOldVersion() const {return fOldVersion;}	Version_t GetOldVersion() const {return fOldVersion;}
	Int_t GetOnFileClassVersion() const {return fOnFileClassVe rsion;}	Int_t GetOnFileClassVersion() const {return fOnFileClassVe rsion;}
	Int_t GetSize() const;	Int_t GetSize() const;
	Int_t GetSizeElements() const;	Int_t GetSizeElements() const;
	TStreamerElement GetStreamerElement(const chardatamember, Int_t& off set) const;	TStreamerElement GetStreamerElement(const chardatamember, Int_t& off set) const;
	TStreamerElement *GetStreamerElementReal(Int_t i, Int_t j) const;	TStreamerElement *GetStreamerElementReal(Int_t i, Int_t j) const;
	Int_t *GetTypes() const {return fType;}	Int_t *GetTypes() const {return fType;}

	Double_t GetValue(char *pointer, Int_t i, Int_t j, Int_t len)	template <typename T> T GetTypedValue(char *pointer, Int_t i, Int_t j, I
	const;	nt_t len) const;
	Double_t GetValueClones(TClonesArray *clones, Int_t i, Int_t	template <typename T> T GetTypedValueClones(TClonesArray *clones, Int_t
	j, Int_t k, Int_t eoffset) const;	i, Int_t j, Int_t k, Int_t eoffset) const;
	Double_t GetValueSTL(TVirtualCollectionProxy *cont, Int_t i,	template <typename T> T GetTypedValueSTL(TVirtualCollectionProxy *cont,
	Int_t j, Int_t k, Int_t eoffset) const;	Int_t i, Int_t j, Int_t k, Int_t eoffset) const;
	Double_t GetValueSTLP(TVirtualCollectionProxy *cont, Int_t i,	template <typename T> T GetTypedValueSTLP(TVirtualCollectionProxy *cont,
	Int_t j, Int_t k, Int_t eoffset) const;	Int_t i, Int_t j, Int_t k, Int_t eoffset) const;
		Double_t GetValue(char *pointer, Int_t i, Int_t j, Int_t len)
		const { return GetTypedValue<Double_t>(pointer, i, j, len); }
		Double_t GetValueClones(TClonesArray *clones, Int_t i, Int_t
		j, Int_t k, Int_t eoffset) const { return GetTypedValueClones<Double_t>(clo
		nes, i, j, k, eoffset); }
		Double_t GetValueSTL(TVirtualCollectionProxy *cont, Int_t i,
		Int_t j, Int_t k, Int_t eoffset) const { return GetTypedValueSTL<Double_t>(
		cont, i, j, k, eoffset); }
		Double_t GetValueSTLP(TVirtualCollectionProxy *cont, Int_t i,
		Int_t j, Int_t k, Int_t eoffset) const { return GetTypedValueSTLP<Double_t
		>(cont, i, j, k, eoffset); }
	void ls(Option_t *option="") const;	void ls(Option_t *option="") const;
	TVirtualStreamerInfo NewInfo(TClass cl) {return new TStreamerInfo(cl); }	TVirtualStreamerInfo NewInfo(TClass cl) {return new TStreamerInfo(cl); }
	void New(void obj = 0);	void New(void obj = 0);
	void NewArray(Long_t nElements, void ary = 0);	void NewArray(Long_t nElements, void ary = 0);
	void Destructor(void* p, Bool_t dtorOnly = kFALSE);	void Destructor(void* p, Bool_t dtorOnly = kFALSE);
	void DeleteArray(void* p, Bool_t dtorOnly = kFALSE);	void DeleteArray(void* p, Bool_t dtorOnly = kFALSE);
	void PrintValue(const char name, char pointer, Int_t i, Int_t len, Int_t lenmax=1000) const;	void PrintValue(const char name, char pointer, Int_t i, Int_t len, Int_t lenmax=1000) const;
	void PrintValueClones(const char name, TClonesArray clo nes, Int_t i, Int_t eoffset, Int_t lenmax=1000) const;	void PrintValueClones(const char name, TClonesArray clo nes, Int_t i, Int_t eoffset, Int_t lenmax=1000) const;
	void PrintValueSTL(const char name, TVirtualCollectionPr oxy cont, Int_t i, Int_t eoffset, Int_t lenmax=1000) const;	void PrintValueSTL(const char name, TVirtualCollectionPr oxy cont, Int_t i, Int_t eoffset, Int_t lenmax=1000) const;


End of changes. 2 change blocks.
	9 lines changed or deleted	20 lines changed or added

	TTree.h	TTree.h

	skipping to change at line 378	skipping to change at line 378
	Long64_t GetDebugMin() const { return fDebugMin; }	Long64_t GetDebugMin() const { return fDebugMin; }
	TDirectory *GetDirectory() const { return fDirectory; }	TDirectory *GetDirectory() const { return fDirectory; }
	virtual Long64_t GetEntries() const { return fEntries; }	virtual Long64_t GetEntries() const { return fEntries; }
	virtual Long64_t GetEntries(const char *selection);	virtual Long64_t GetEntries(const char *selection);
	virtual Long64_t GetEntriesFast() const { return fEntries; }	virtual Long64_t GetEntriesFast() const { return fEntries; }
	virtual Long64_t GetEntriesFriend() const;	virtual Long64_t GetEntriesFriend() const;
	virtual Long64_t GetEstimate() const { return fEstimate; }	virtual Long64_t GetEstimate() const { return fEstimate; }
	virtual Int_t GetEntry(Long64_t entry = 0, Int_t getall = 0);	virtual Int_t GetEntry(Long64_t entry = 0, Int_t getall = 0);
	Int_t GetEvent(Long64_t entry = 0, Int_t getall = 0) { return GetEntry(entry, getall); }	Int_t GetEvent(Long64_t entry = 0, Int_t getall = 0) { return GetEntry(entry, getall); }
	virtual Int_t GetEntryWithIndex(Int_t major, Int_t minor = 0);	virtual Int_t GetEntryWithIndex(Int_t major, Int_t minor = 0);

	virtual Long64_t GetEntryNumberWithBestIndex(Int_t major, Int_t m	virtual Long64_t GetEntryNumberWithBestIndex(Long64_t major, Long
	inor = 0) const;	64_t minor = 0) const;
	virtual Long64_t GetEntryNumberWithIndex(Int_t major, Int_t minor	virtual Long64_t GetEntryNumberWithIndex(Long64_t major, Long64_t
	= 0) const;	minor = 0) const;
	TEventList *GetEventList() const { return fEventList; }	TEventList *GetEventList() const { return fEventList; }
	virtual TEntryList *GetEntryList();	virtual TEntryList *GetEntryList();
	virtual Long64_t GetEntryNumber(Long64_t entry) const;	virtual Long64_t GetEntryNumber(Long64_t entry) const;
	virtual Int_t GetFileNumber() const { return fFileNumber; }	virtual Int_t GetFileNumber() const { return fFileNumber; }
	virtual TTree GetFriend(const char) const;	virtual TTree GetFriend(const char) const;
	virtual const char GetFriendAlias(TTree) const;	virtual const char GetFriendAlias(TTree) const;
	TH1 *GetHistogram() { return GetPlayer()->GetHistogra m(); }	TH1 *GetHistogram() { return GetPlayer()->GetHistogra m(); }
	virtual Int_t *GetIndex() { return &fIndex.fArray[0]; }	virtual Int_t *GetIndex() { return &fIndex.fArray[0]; }
	virtual Double_t *GetIndexValues() { return &fIndexValues.fArray[0 ]; }	virtual Double_t *GetIndexValues() { return &fIndexValues.fArray[0 ]; }
	virtual TIterator *GetIteratorOnAllLeaves(Bool_t dir = kIterForward );	virtual TIterator *GetIteratorOnAllLeaves(Bool_t dir = kIterForward );

End of changes. 1 change blocks.
	4 lines changed or deleted	4 lines changed or added

	TTreeFormula.h	TTreeFormula.h

	skipping to change at line 124	skipping to change at line 124
	TTreeFormula *fVarIndexes[kMAXCODES][kMAXFORMDIM]; //Pointer to a varia ble index.	TTreeFormula *fVarIndexes[kMAXCODES][kMAXFORMDIM]; //Pointer to a varia ble index.

	TAxis *fAxis; //! pointer to histogram axis if this is a string	TAxis *fAxis; //! pointer to histogram axis if this is a string
	Bool_t fDidBooleanOptimization; //! True if we execu ted one boolean optimization since the last time instance number 0 was eval uated	Bool_t fDidBooleanOptimization; //! True if we execu ted one boolean optimization since the last time instance number 0 was eval uated
	TTreeFormulaManager *fManager; //! The dimension coordinator .	TTreeFormulaManager *fManager; //! The dimension coordinator .

	// Helper members and function used during the construction and parsing	// Helper members and function used during the construction and parsing
	TList *fDimensionSetup; //! list of dimension setups, for delayed creation of the dimension information.	TList *fDimensionSetup; //! list of dimension setups, for delayed creation of the dimension information.
	std::vector<std::string> fAliasesUsed; //! List of aliases used duri ng the parsing of the expression.	std::vector<std::string> fAliasesUsed; //! List of aliases used duri ng the parsing of the expression.


		LongDouble_t* fConstLD; // local version of fConsts able to sto
		re bigger numbers

	TTreeFormula(const char name, const char formula, TTree *tree, const s td::vector<std::string>& aliases);	TTreeFormula(const char name, const char formula, TTree *tree, const s td::vector<std::string>& aliases);
	void Init(const char name, const char formula);	void Init(const char name, const char formula);
	Bool_t BranchHasMethod(TLeaf* leaf, TBranch* branch, const char* me thod,const char* params, Long64_t readentry) const;	Bool_t BranchHasMethod(TLeaf* leaf, TBranch* branch, const char* me thod,const char* params, Long64_t readentry) const;
	Int_t DefineAlternate(const char* expression);	Int_t DefineAlternate(const char* expression);
	void DefineDimensions(Int_t code, Int_t size, TFormLeafInfoMultiV arDim * info, Int_t& virt_dim);	void DefineDimensions(Int_t code, Int_t size, TFormLeafInfoMultiV arDim * info, Int_t& virt_dim);
	Int_t FindLeafForExpression(const char* expression, TLeaf &leaf, TString &leftover, Bool_t &final, UInt_t &paran_level, TObjArray &castqueue , std::vector<std::string>& aliasUsed, Bool_t &useLeafCollectionObject, con st char fullExpression);	Int_t FindLeafForExpression(const char* expression, TLeaf &leaf, TString &leftover, Bool_t &final, UInt_t &paran_level, TObjArray &castqueue , std::vector<std::string>& aliasUsed, Bool_t &useLeafCollectionObject, con st char fullExpression);
	TLeaf* GetLeafWithDatamember(const char* topchoice, const char* nex tchice, Long64_t readentry) const;	TLeaf* GetLeafWithDatamember(const char* topchoice, const char* nex tchice, Long64_t readentry) const;
	Int_t ParseWithLeaf(TLeaf leaf, const char expression, Bool_t fi nal, UInt_t paran_level, TObjArray &castqueue, Bool_t useLeafCollectionObje ct, const char *fullExpression);	Int_t ParseWithLeaf(TLeaf leaf, const char expression, Bool_t fi nal, UInt_t paran_level, TObjArray &castqueue, Bool_t useLeafCollectionObje ct, const char *fullExpression);
	Int_t RegisterDimensions(Int_t code, Int_t size, TFormLeafInfoMult iVarDim * multidim = 0);	Int_t RegisterDimensions(Int_t code, Int_t size, TFormLeafInfoMult iVarDim * multidim = 0);
	Int_t RegisterDimensions(Int_t code, TBranchElement *branch);	Int_t RegisterDimensions(Int_t code, TBranchElement *branch);

	skipping to change at line 160	skipping to change at line 162
	virtual Bool_t SwitchToFormLeafInfo(Int_t code);	virtual Bool_t SwitchToFormLeafInfo(Int_t code);
	virtual Bool_t StringToNumber(Int_t code);	virtual Bool_t StringToNumber(Int_t code);

	void Convert(UInt_t fromVersion);	void Convert(UInt_t fromVersion);

	private:	private:
	// Not implemented yet	// Not implemented yet
	TTreeFormula(const TTreeFormula&);	TTreeFormula(const TTreeFormula&);
	TTreeFormula& operator=(const TTreeFormula&);	TTreeFormula& operator=(const TTreeFormula&);


		template<typename T> T GetConstant(Int_t k);

	public:	public:
	TTreeFormula();	TTreeFormula();
	TTreeFormula(const char name,const char formula, TTree *tree);	TTreeFormula(const char name,const char formula, TTree *tree);
	virtual ~TTreeFormula();	virtual ~TTreeFormula();

	virtual Int_t DefinedVariable(TString &variable, Int_t &action);	virtual Int_t DefinedVariable(TString &variable, Int_t &action);
	virtual TClass* EvalClass() const;	virtual TClass* EvalClass() const;

	virtual Double_t EvalInstance(Int_t i=0, const char *stringStack[]=0)
	;	template<typename T> T EvalInstance(Int_t i=0, const char *stringStack[]
		=0);
		virtual Double_t EvalInstance(Int_t i=0, const char *stringStack[]
		=0) {return EvalInstance<Double_t>(i, stringStack); }
		virtual Long64_t EvalInstance64(Int_t i=0, const char *stringStack
		[]=0) {return EvalInstance<Long64_t>(i, stringStack); }
		virtual LongDouble_t EvalInstanceLD(Int_t i=0, const char *stringStack
		[]=0) {return EvalInstance<LongDouble_t>(i, stringStack); }

	virtual const char *EvalStringInstance(Int_t i=0);	virtual const char *EvalStringInstance(Int_t i=0);
	virtual void* EvalObject(Int_t i=0);	virtual void* EvalObject(Int_t i=0);
	// EvalInstance should be const. See comment on GetNdata()	// EvalInstance should be const. See comment on GetNdata()
	TFormLeafInfo *GetLeafInfo(Int_t code) const;	TFormLeafInfo *GetLeafInfo(Int_t code) const;
	TTreeFormulaManager*GetManager() const { return fManager; }	TTreeFormulaManager*GetManager() const { return fManager; }
	TMethodCall *GetMethodCall(Int_t code) const;	TMethodCall *GetMethodCall(Int_t code) const;
	virtual Int_t GetMultiplicity() const {return fMultiplicity;}	virtual Int_t GetMultiplicity() const {return fMultiplicity;}
	virtual TLeaf *GetLeaf(Int_t n) const;	virtual TLeaf *GetLeaf(Int_t n) const;
	virtual Int_t GetNcodes() const {return fNcodes;}	virtual Int_t GetNcodes() const {return fNcodes;}
	virtual Int_t GetNdata();	virtual Int_t GetNdata();

End of changes. 3 change blocks.
	2 lines changed or deleted	15 lines changed or added

	TUrl.h	TUrl.h

	skipping to change at line 81	skipping to change at line 81
	const char *GetProtocol() const { return fProtocol; }	const char *GetProtocol() const { return fProtocol; }
	const char *GetUser() const { return fUser; }	const char *GetUser() const { return fUser; }
	const char *GetPasswd() const { return fPasswd; }	const char *GetPasswd() const { return fPasswd; }
	const char *GetHost() const { return fHost; }	const char *GetHost() const { return fHost; }
	const char *GetHostFQDN() const;	const char *GetHostFQDN() const;
	const char *GetFile() const { return fFile; }	const char *GetFile() const { return fFile; }
	const char *GetAnchor() const { return fAnchor; }	const char *GetAnchor() const { return fAnchor; }
	const char *GetOptions() const { return fOptions; }	const char *GetOptions() const { return fOptions; }
	const char GetValueFromOptions(const char key) const;	const char GetValueFromOptions(const char key) const;
	Int_t GetIntValueFromOptions(const char *key) const;	Int_t GetIntValueFromOptions(const char *key) const;

		Bool_t HasOption(const char *key) const;
	void ParseOptions() const;	void ParseOptions() const;
	void CleanRelativePath();	void CleanRelativePath();
	const char *GetFileAndOptions() const;	const char *GetFileAndOptions() const;
	Int_t GetPort() const { return fPort; }	Int_t GetPort() const { return fPort; }
	Bool_t IsValid() const { return fPort == -1 ? kFALSE : kTRUE; }	Bool_t IsValid() const { return fPort == -1 ? kFALSE : kTRUE; }

	void SetProtocol(const char *proto, Bool_t setDefaultPort = kFALS E);	void SetProtocol(const char *proto, Bool_t setDefaultPort = kFALS E);
	void SetUser(const char *user) { fUser = user; fUrl = ""; }	void SetUser(const char *user) { fUser = user; fUrl = ""; }
	void SetPasswd(const char *pw) { fPasswd = pw; fUrl = ""; }	void SetPasswd(const char *pw) { fPasswd = pw; fUrl = ""; }
	void SetHost(const char *host) { fHost = host; fUrl = ""; }	void SetHost(const char *host) { fHost = host; fUrl = ""; }

End of changes. 1 change blocks.
	0 lines changed or deleted	1 lines changed or added