ROOT: headers diff between 5.27.06 and 5.28.00 versions

	AdaptiveIntegratorMultiDim.h	AdaptiveIntegratorMultiDim.h

	// @(#)root/mathcore:$Id: AdaptiveIntegratorMultiDim.h 34992 2010-08-25 10: 36:11Z moneta $	// @(#)root/mathcore:$Id: AdaptiveIntegratorMultiDim.h 36768 2010-11-19 10: 34:53Z moneta $
	// Author: M. Slawinska 08/2007	// Author: M. Slawinska 08/2007

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2007 , LCG ROOT MathLib Team *	* Copyright (c) 2007 , LCG ROOT MathLib Team *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header source file for class AdaptiveIntegratorMultiDim	// Header source file for class AdaptiveIntegratorMultiDim

	skipping to change at line 43	skipping to change at line 43

	@ingroup Integration	@ingroup Integration

	*/	*/

	class AdaptiveIntegratorMultiDim : public VirtualIntegratorMultiDim {	class AdaptiveIntegratorMultiDim : public VirtualIntegratorMultiDim {

	public:	public:

	/**	/**

	construct given optionally tolerance (absolute and relative) and maxi	construct given optionally tolerance (absolute and relative), maximum
	mum size of working array	number of function evaluation (maxpts) and
		size of the working array.
	The size of working array represents the number of sub-division used for calculating the integral.	The size of working array represents the number of sub-division used for calculating the integral.
	Higher the dimension, larger sizes are required for getting the same accuracy.	Higher the dimension, larger sizes are required for getting the same accuracy.

		The size must be larger than >= (2N + 3) * (1 + MAXPTS/(2**N + 2N(N
		+ 1) + 1))/2). For smaller value passed, the
		minimum allowed will be used
	*/	*/
	explicit	explicit

	AdaptiveIntegratorMultiDim(double absTol = 1.E-6, double relTol = 1E-6, unsigned int size = 100000);	AdaptiveIntegratorMultiDim(double absTol = 1.E-6, double relTol = 1E-6, unsigned int maxpts = 100000, unsigned int size = 0);

	/**	/**

	construct with a reference to the integrand function and given option	Construct with a reference to the integrand function and given option
	ally	ally
	tolerance (absolute and relative) and maximum size of working array.	tolerance (absolute and relative), maximum number of function evaluat
		ion (maxpts) and
		size of the working array.
	*/	*/
	explicit	explicit

	AdaptiveIntegratorMultiDim(const IMultiGenFunction &f, double absTol = 1 .E-9, double relTol = 1E-6, unsigned int size = 100000);	AdaptiveIntegratorMultiDim(const IMultiGenFunction &f, double absTol = 1 .E-9, double relTol = 1E-6, unsigned int maxcall = 100000, unsigned int si ze = 0);

	/**	/**
	destructor (no operations)	destructor (no operations)
	*/	*/
	virtual ~AdaptiveIntegratorMultiDim() {}	virtual ~AdaptiveIntegratorMultiDim() {}

	/**	/**
	evaluate the integral with the previously given function between xmin [] and xmax[]	evaluate the integral with the previously given function between xmin [] and xmax[]
	*/	*/
	double Integral(const double* xmin, const double * xmax) {	double Integral(const double* xmin, const double * xmax) {

	skipping to change at line 88	skipping to change at line 92
	/// return integration error	/// return integration error
	double Error() const { return fError; }	double Error() const { return fError; }

	/// return relative error	/// return relative error
	double RelError() const { return fRelError; }	double RelError() const { return fRelError; }

	/// return status of integration	/// return status of integration
	int Status() const { return fStatus; }	int Status() const { return fStatus; }

	/// return number of function evaluations in calculating the integral	/// return number of function evaluations in calculating the integral

	unsigned int NEval() const { return fNEval; }	int NEval() const { return fNEval; }

	/// set relative tolerance	/// set relative tolerance
	void SetRelTolerance(double relTol);	void SetRelTolerance(double relTol);

	/// set absolute tolerance	/// set absolute tolerance
	void SetAbsTolerance(double absTol);	void SetAbsTolerance(double absTol);


		///set workspace size
		void SetSize(unsigned int size) { fSize = size; }

		///set min points
		void SetMinPts(unsigned int n) { fMinPts = n; }

		///set max points
		void SetMaxPts(unsigned int n) { fMaxPts = n; }

		/// set the options
		void SetOptions(const ROOT::Math::IntegratorMultiDimOptions & opt);

		/// get the option used for the integration
		ROOT::Math::IntegratorMultiDimOptions Options() const;

	protected:	protected:

	// internal function to compute the integral (if absVal is true compute abs value of function integral	// internal function to compute the integral (if absVal is true compute abs value of function integral
	double DoIntegral(const double* xmin, const double * xmax, bool absVal = false);	double DoIntegral(const double* xmin, const double * xmax, bool absVal = false);

	private:	private:

	unsigned int fDim; // dimentionality of integrand	unsigned int fDim; // dimentionality of integrand

		unsigned int fMinPts; // minimum number of function evaluation reques
		ted
		unsigned int fMaxPts; // maximum number of function evaluation reques
		ted
		unsigned int fSize; // max size of working array (explode with dimens
		ion)
	double fAbsTol; // absolute tolerance	double fAbsTol; // absolute tolerance
	double fRelTol; // relative tolerance	double fRelTol; // relative tolerance

	unsigned int fSize; // max size of working array (explode with dimens ion)

	double fResult; // last integration result	double fResult; // last integration result
	double fError; // integration error	double fError; // integration error
	double fRelError; // Relative error	double fRelError; // Relative error

	unsigned int fNEval; // number of function evaluation	int fNEval; // number of function evaluation
	int fStatus; // status of algorithm (error if not zero)	int fStatus; // status of algorithm (error if not zero)

	const IMultiGenFunction* fFun; // pointer to integrand function	const IMultiGenFunction* fFun; // pointer to integrand function

	};	};

	}//namespace Math	}//namespace Math
	}//namespace ROOT	}//namespace ROOT

	#endif /* ROOT_Math_AdaptiveIntegratorMultiDim */	#endif /* ROOT_Math_AdaptiveIntegratorMultiDim */

End of changes. 11 change blocks.
	12 lines changed or deleted	37 lines changed or added

	AllIntegrationTypes.h	AllIntegrationTypes.h

	// @(#)root/mathmore:$Id: AllIntegrationTypes.h 33180 2010-04-25 10:14:07Z moneta $	// @(#)root/mathmore:$Id: AllIntegrationTypes.h 36764 2010-11-19 10:02:00Z moneta $
	// Author: Magdalena Slawinska 10/2007	// Author: Magdalena Slawinska 10/2007

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2007 ROOT Foundation, CERN/PH-SFT *	* Copyright (c) 2007 ROOT Foundation, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Integration types for	// Integration types for

	skipping to change at line 29	skipping to change at line 29
	namespace Math {	namespace Math {

	// type of integration	// type of integration

	//for 1-dim integration	//for 1-dim integration
	namespace IntegrationOneDim {	namespace IntegrationOneDim {

	/**	/**
	enumeration specifying the integration types.	enumeration specifying the integration types.
	<ul>	<ul>

		<li>kDEFAULT: default type specifiend in the static options
	<li>kGAUSS: simple Gauss integration method with fixed rule	<li>kGAUSS: simple Gauss integration method with fixed rule
	<li>kLEGENDRE: Gauss-Legendre integration	<li>kLEGENDRE: Gauss-Legendre integration
	<li>kNONADAPTIVE : to be used for smooth functions	<li>kNONADAPTIVE : to be used for smooth functions
	<li>kADAPTIVE : to be used for general functions without singularit ies.	<li>kADAPTIVE : to be used for general functions without singularit ies.
	<li>kADAPTIVESINGULAR: default adaptive integration type which can be used in the case of the presence of singularities.	<li>kADAPTIVESINGULAR: default adaptive integration type which can be used in the case of the presence of singularities.
	</ul>	</ul>
	@ingroup Integration	@ingroup Integration
	*/	*/

	enum Type { kGAUSS, kLEGENDRE, kADAPTIVE, kADAPTIVESINGULAR, kNONADAPT IVE};	enum Type { kDEFAULT = -1, kGAUSS, kLEGENDRE, kADAPTIVE, kADAPTIVESING ULAR, kNONADAPTIVE};

	}	}

	//for multi-dim integration	//for multi-dim integration
	namespace IntegrationMultiDim {	namespace IntegrationMultiDim {

	/**	/**
	enumeration specifying the integration types.	enumeration specifying the integration types.
	<ul>	<ul>

	<li>ADAPTIVE : adaptive multi-dimensional integration	<li>kDEFAULT : default type specified in the static option
	<li>PLAIN MC integration	<li>kADAPTIVE : adaptive multi-dimensional integration
	<li>MISER MC integration	<li>kPLAIN MC integration
	<li>VEGAS MC integration	<li>kMISER MC integration
		<li>kVEGAS MC integration
	</ul>	</ul>
	@ingroup MCIntegration	@ingroup MCIntegration
	*/	*/


	enum Type {kADAPTIVE, kVEGAS, kMISER, kPLAIN};	enum Type {kDEFAULT = -1, kADAPTIVE, kVEGAS, kMISER, kPLAIN};

	}	}

	} // namespace Math	} // namespace Math
	} // namespace ROOT	} // namespace ROOT

	#endif /* ROOT_Math_AllIntegrationTypes */	#endif /* ROOT_Math_AllIntegrationTypes */

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

	Api.h	Api.h

	skipping to change at line 37	skipping to change at line 37
	#pragma link off all classes;	#pragma link off all classes;
	#pragma link off all functions;	#pragma link off all functions;
	#pragma link off all globals;	#pragma link off all globals;
	#pragma link off all typedefs;	#pragma link off all typedefs;
	#endif	#endif

	#define G__INFO_BUFLEN 50	#define G__INFO_BUFLEN 50
	/* #define G__INFO_TITLELEN 256 */	/* #define G__INFO_TITLELEN 256 */
	#define G__INFO_TITLELEN G__ONELINE	#define G__INFO_TITLELEN G__ONELINE


		#ifndef G__PROPERTY_H
	#include "Property.h"	#include "Property.h"

		#endif
		#ifndef G__CLASSINFO_H
	#include "Class.h"	#include "Class.h"

		#endif
		#ifndef G__BaseClassInfo_H
	#include "BaseCls.h"	#include "BaseCls.h"

		#endif
		#ifndef G__TYPEINFOX_H
	#include "Type.h"	#include "Type.h"

		#endif
		#ifndef G__METHODINFO_H
	#include "Method.h"	#include "Method.h"

		#endif
		#ifndef G__METHODARGINFO_H
	#include "MethodAr.h"	#include "MethodAr.h"

		#endif
		#ifndef G__DATAMEMBER_H
	#include "DataMbr.h"	#include "DataMbr.h"

		#endif
		#ifndef G__CALLFUNC_H
	#include "CallFunc.h"	#include "CallFunc.h"

		#endif
		#ifndef G__TYPEDEFINFO_H
	#include "Typedf.h"	#include "Typedf.h"

		#endif
		#ifndef G__TOKENINFO_H
	#include "Token.h"	#include "Token.h"

		#endif

	#include <vector>	#include <vector>
	#include <string>	#include <string>

	#ifndef __CINT__	#ifndef __CINT__
	struct G__includepath;	struct G__includepath;
	#endif	#endif

	extern "C" {	extern "C" {
	#ifndef __CINT__	#ifndef __CINT__

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

	BaseCls.h	BaseCls.h

	skipping to change at line 20	skipping to change at line 20
	* Author Masaharu Goto	* Author Masaharu Goto
	* Copyright(c) 1995~1999 Masaharu Goto	* Copyright(c) 1995~1999 Masaharu Goto
	*	*
	* For the licensing terms see the file COPYING	* For the licensing terms see the file COPYING
	*	*
	************************************************************************/	************************************************************************/

	#ifndef G__BaseClassInfo_H	#ifndef G__BaseClassInfo_H
	#define G__BaseClassInfo_H	#define G__BaseClassInfo_H


		#ifndef G__API_H
	#include "Api.h"	#include "Api.h"

		#endif

	namespace Cint {	namespace Cint {

	/*********************************************************************	/*********************************************************************
	* class G__BaseClassInfo	* class G__BaseClassInfo
	*	*
	* Rene says OK	* Rene says OK
	*	*
	*********************************************************************/	*********************************************************************/
	class	class

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

	BinarySearchTree.h	BinarySearchTree.h

	// @(#)root/tmva $Id: BinarySearchTree.h 31458 2009-11-30 13:58:20Z stelzer $	// @(#)root/tmva $Id: BinarySearchTree.h 37399 2010-12-08 15:22:07Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : BinarySearchTree *	* Class : BinarySearchTree *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* BinarySearchTree incl. volume Search method *	* BinarySearchTree incl. volume Search method *

	skipping to change at line 87	skipping to change at line 87
	BinarySearchTree( void );	BinarySearchTree( void );

	// copy constructor	// copy constructor
	BinarySearchTree (const BinarySearchTree &b);	BinarySearchTree (const BinarySearchTree &b);

	// destructor	// destructor
	virtual ~BinarySearchTree( void );	virtual ~BinarySearchTree( void );

	virtual Node * CreateNode( UInt_t ) const { return new BinarySearchTr eeNode(); }	virtual Node * CreateNode( UInt_t ) const { return new BinarySearchTr eeNode(); }
	virtual BinaryTree* CreateTree() const { return new BinarySearchTree( ); }	virtual BinaryTree* CreateTree() const { return new BinarySearchTree( ); }

		static BinarySearchTree* CreateFromXML(void* node, UInt_t tmva_Versio n_Code = TMVA_VERSION_CODE);
	virtual const char* ClassName() const { return "BinarySearchTree"; }	virtual const char* ClassName() const { return "BinarySearchTree"; }

	// Searches for a node with the specified data	// Searches for a node with the specified data
	// by calling the private, recursive, function for searching	// by calling the private, recursive, function for searching
	BinarySearchTreeNode* Search( Event * event ) const;	BinarySearchTreeNode* Search( Event * event ) const;

	// Adds an item to the tree,	// Adds an item to the tree,
	void Insert( const Event * );	void Insert( const Event * );

	// get sum of weights of the nodes;	// get sum of weights of the nodes;

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

	BrentMethods.h	BrentMethods.h

	skipping to change at line 25	skipping to change at line 25
	use Brent's method with the bracketed interval	use Brent's method with the bracketed interval
	The step of the search is set to (xmax-xmin)/fNpx	The step of the search is set to (xmax-xmin)/fNpx
	type: 0-returns MinimumX	type: 0-returns MinimumX
	1-returns Minimum	1-returns Minimum
	2-returns MaximumX	2-returns MaximumX
	3-returns Maximum	3-returns Maximum
	4-returns X corresponding to fy	4-returns X corresponding to fy

	*/	*/


	double MinimStep(const IGenFunction* f, int type, double &xmin, double & xmax, double fy, int npx = 100);	double MinimStep(const IGenFunction* f, int type, double &xmin, double & xmax, double fy, int npx = 100, bool useLog = false);

	/**	/**
	Finds a minimum of a function, if the function is unimodal between x min and xmax	Finds a minimum of a function, if the function is unimodal between x min and xmax
	This method uses a combination of golden section search and parabolic interpolation	This method uses a combination of golden section search and parabolic interpolation
	Details about convergence and properties of this algorithm can be	Details about convergence and properties of this algorithm can be
	found in the book by R.P.Brent "Algorithms for Minimization Without D erivatives"	found in the book by R.P.Brent "Algorithms for Minimization Without D erivatives"
	or in the "Numerical Recipes", chapter 10.2	or in the "Numerical Recipes", chapter 10.2
	convergence is reached using tolerance = 2 ( epsrel abs(x) + epsa bs)	convergence is reached using tolerance = 2 ( epsrel abs(x) + epsa bs)

	type: 0-returns MinimumX	type: 0-returns MinimumX

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

	CallFunc.h	CallFunc.h

	skipping to change at line 19	skipping to change at line 19
	************************************************************************	************************************************************************
	* Copyright(c) 1995~2003 Masaharu Goto	* Copyright(c) 1995~2003 Masaharu Goto
	*	*
	* For the licensing terms see the file COPYING	* For the licensing terms see the file COPYING
	*	*
	************************************************************************/	************************************************************************/

	#ifndef G__CALLFUNC_H	#ifndef G__CALLFUNC_H
	#define G__CALLFUNC_H	#define G__CALLFUNC_H


		#ifndef G__API_H
	#include "Api.h"	#include "Api.h"

		#endif

	namespace Cint {	namespace Cint {

	/*********************************************************************	/*********************************************************************
	* class G__CallFunc	* class G__CallFunc
	*	*
	*	*
	*********************************************************************/	*********************************************************************/
	class	class
	#ifndef __CINT__	#ifndef __CINT__

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

	CholeskyDecomp.h	CholeskyDecomp.h

	// @(#)root/smatrix:$Id: CholeskyDecomp.h 30561 2009-10-05 14:23:15Z moneta $	// @(#)root/smatrix:$Id: CholeskyDecomp.h 36350 2010-10-14 13:40:45Z moneta $
	// Author: M. Schiller 2009	// Author: M. Schiller 2009

	#ifndef ROOT_Math_CholeskyDecomp	#ifndef ROOT_Math_CholeskyDecomp
	#define ROOT_Math_CholeskyDecomp	#define ROOT_Math_CholeskyDecomp

	/** @file	/** @file
	* header file containing the templated implementation of matrix inversion	* header file containing the templated implementation of matrix inversion
	* routines for use with ROOT's SMatrix classes (symmetric positive	* routines for use with ROOT's SMatrix classes (symmetric positive
	* definite case)	* definite case)
	*	*
	* @author Manuel Schiller	* @author Manuel Schiller
	* @date Aug 29 2008	* @date Aug 29 2008
	* initial release inside LHCb	* initial release inside LHCb
	* @date May 7 2009	* @date May 7 2009
	* factored code to provide a nice Cholesky decomposition class, along	* factored code to provide a nice Cholesky decomposition class, along
	* with separate methods for solving a single linear system and to	* with separate methods for solving a single linear system and to
	* obtain the inverse matrix from the decomposition	* obtain the inverse matrix from the decomposition
	*/	*/


		#include <cmath>
		#include <algorithm>

	namespace ROOT {	namespace ROOT {

	namespace Math {	namespace Math {

	/// helpers for CholeskyDecomp	/// helpers for CholeskyDecomp
	namespace CholeskyDecompHelpers {	namespace CholeskyDecompHelpers {
	// forward decls	// forward decls
	template<class F, unsigned N, class M> struct _decomposer;	template<class F, unsigned N, class M> struct _decomposer;
	template<class F, unsigned N, class M> struct _inverter;	template<class F, unsigned N, class M> struct _inverter;
	template<class F, unsigned N, class V> struct _solver;	template<class F, unsigned N, class V> struct _solver;

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

	Class.h	Class.h

	skipping to change at line 19	skipping to change at line 19
	************************************************************************	************************************************************************
	* Copyright(c) 1995~1998 Masaharu Goto	* Copyright(c) 1995~1998 Masaharu Goto
	*	*
	* For the licensing terms see the file COPYING	* For the licensing terms see the file COPYING
	*	*
	************************************************************************/	************************************************************************/

	#ifndef G__CLASSINFO_H	#ifndef G__CLASSINFO_H
	#define G__CLASSINFO_H	#define G__CLASSINFO_H


		#ifndef G__API_H
	#include "Api.h"	#include "Api.h"

		#endif

	namespace Cint {	namespace Cint {

	class G__MethodInfo;	class G__MethodInfo;
	class G__DataMemberInfo;	class G__DataMemberInfo;
	class G__FriendInfo;	class G__FriendInfo;

	/*********************************************************************	/*********************************************************************
	* class G__ClassInfo	* class G__ClassInfo
	*	*

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

	CollectionProxy.h	CollectionProxy.h

	// @(#)root/reflex:$Id: CollectionProxy.h 35298 2010-09-15 12:29:16Z pcanal $	// @(#)root/reflex:$Id: CollectionProxy.h 36698 2010-11-16 16:40:22Z axel $
	// Author: Markus Frank 2004	// Author: Markus Frank 2004

	// Copyright CERN, CH-1211 Geneva 23, 2004-2006, All rights reserved.	// Copyright CERN, CH-1211 Geneva 23, 2004-2006, All rights reserved.
	//	//
	// Permission to use, copy, modify, and distribute this software for any	// Permission to use, copy, modify, and distribute this software for any
	// purpose is hereby granted without fee, provided that this copyright and	// purpose is hereby granted without fee, provided that this copyright and
	// permissions notice appear in all copies and derivatives.	// permissions notice appear in all copies and derivatives.
	//	//
	// This software is provided "as is" without express or implied warranty.	// This software is provided "as is" without express or implied warranty.

	#ifndef Reflex_CollectionProxy	#ifndef Reflex_CollectionProxy
	#define Reflex_CollectionProxy 1 1	#define Reflex_CollectionProxy 1 1

	#include <cstddef>	#include <cstddef>

	// Macro indicating the version of the Collection Proxy interface followed	// Macro indicating the version of the Collection Proxy interface followed
	// by this Reflex build, this must match the version number of	// by this Reflex build, this must match the version number of
	// ROOT_COLLECTIONPROXY_VERSION in ROOT's TVirtutalCollectionProxy.h	// ROOT_COLLECTIONPROXY_VERSION in ROOT's TVirtutalCollectionProxy.h


	#define REFLEX_COLLECTIONPROXY_VERSION 2	#define REFLEX_COLLECTIONPROXY_VERSION 3

	// Forward declarations	// Forward declarations
	namespace std {	namespace std {
	template <class T, class A> class deque;	template <class T, class A> class deque;
	template <class T, class A> class vector;	template <class T, class A> class vector;
	template <class T, class A> class list;	template <class T, class A> class list;
	template <class T, class A> class queue;	template <class T, class A> class queue;
	template <class T, class A> class stack;	template <class T, class A> class stack;
	template <class K, class T, class A> class set;	template <class K, class T, class A> class set;
	template <class K, class T, class A> class multiset;	template <class K, class T, class A> class multiset;

	skipping to change at line 110	skipping to change at line 110

	};	};

	template <class T> struct CollType	template <class T> struct CollType
	#ifdef _KCC // KAI compiler	#ifdef _KCC // KAI compiler
	: public Address<typename T::value_type&>	: public Address<typename T::value_type&>
	#else	#else
	: public Address<typename T::const_reference>	: public Address<typename T::const_reference>
	#endif	#endif
	{	{

		#ifdef _KCC // KAI compiler
		typedef Address<typename T::value_type&> Address_t;
		#else
		typedef Address<typename T::const_reference> Address_t;
		#endif
	typedef T Cont_t;	typedef T Cont_t;
	typedef typename T::iterator Iter_t;	typedef typename T::iterator Iter_t;
	typedef typename T::value_type Value_t;	typedef typename T::value_type Value_t;
	typedef Reflex::Environ<Iter_t> Env_t;	typedef Reflex::Environ<Iter_t> Env_t;
	typedef Env_t* PEnv_t;	typedef Env_t* PEnv_t;
	typedef Cont_t* PCont_t;	typedef Cont_t* PCont_t;
	typedef Value_t* PValue_t;	typedef Value_t* PValue_t;

	static inline PCont_t	static inline PCont_t
	object(void* ptr) {	object(void* ptr) {

	skipping to change at line 150	skipping to change at line 155
	// Assume iterators do not need destruction	// Assume iterators do not need destruction
	e->fIterator = c->begin();	e->fIterator = c->begin();
	e->fSize = c->size();	e->fSize = c->size();

	if (0 == e->fSize) { return e->fStart = 0; }	if (0 == e->fSize) { return e->fStart = 0; }
	#ifdef _KCC // KAI compiler	#ifdef _KCC // KAI compiler
	typename T::value_type& ref = *(e->iter());	typename T::value_type& ref = *(e->iter());
	#else	#else
	typename T::const_reference ref = *(e->iter());	typename T::const_reference ref = *(e->iter());
	#endif	#endif

	return e->fStart = address(ref);	return e->fStart = Address_t::address(ref);
	}	}

	static void*	static void*
	next(void* env) {	next(void* env) {
	PEnv_t e = PEnv_t(env);	PEnv_t e = PEnv_t(env);
	PCont_t c = PCont_t(e->fObject);	PCont_t c = PCont_t(e->fObject);

	for ( ; e->fIdx > 0 && e->iter() != c->end(); ++(e->iter()), --e->fId x) {}	for ( ; e->fIdx > 0 && e->iter() != c->end(); ++(e->iter()), --e->fId x) {}

	// TODO: Need to find something for going backwards....	// TODO: Need to find something for going backwards....
	if (e->iter() == c->end()) { return 0; }	if (e->iter() == c->end()) { return 0; }
	#ifdef _KCC // KAI compiler	#ifdef _KCC // KAI compiler
	typename T::value_type& ref = *(e->iter());	typename T::value_type& ref = *(e->iter());
	#else	#else
	typename T::const_reference ref = *(e->iter());	typename T::const_reference ref = *(e->iter());
	#endif	#endif

	return address(ref);	return Address_t::address(ref);
	}	}

	static void*	static void*

	construct(void* env) {	construct(void* what, size_t size) {
	PEnv_t e = PEnv_t(env);	PValue_t m = PValue_t(what);
	PValue_t m = PValue_t(e->fStart);


	for (size_t i = 0; i < e->fSize; ++i, ++m) {	for (size_t i = 0; i < size; ++i, ++m) {
	::new (m) Value_t();	::new (m) Value_t();
	}	}
	return 0;	return 0;
	}	}

	static void*	static void*
	collect(void* env) {	collect(void* env) {
	PEnv_t e = PEnv_t(env);	PEnv_t e = PEnv_t(env);
	PCont_t c = PCont_t(e->fObject);	PCont_t c = PCont_t(e->fObject);
	PValue_t m = PValue_t(e->fStart);	PValue_t m = PValue_t(e->fStart);

	for (Iter_t i = c->begin(); i != c->end(); ++i, ++m) {	for (Iter_t i = c->begin(); i != c->end(); ++i, ++m) {
	::new (m) Value_t(*i);	::new (m) Value_t(*i);
	}	}
	return 0;	return 0;
	}	}


	static void*	static void
	destruct(void* env) {	destruct(void* what, size_t size) {
	PEnv_t e = PEnv_t(env);	PValue_t m = PValue_t(what);
	PValue_t m = PValue_t(e->fStart);


	for (size_t i = 0; i < e->fSize; ++i, ++m) {	for (size_t i = 0; i < size; ++i, ++m) {
	m->~Value_t();	m->~Value_t();
	}	}

	return 0;
	}	}

	};	};

	/** @class TCollectionProxy::Map TCollectionProxy.h TCollectionProxy.h	/** @class TCollectionProxy::Map TCollectionProxy.h TCollectionProxy.h
	*	*
	* Small helper to encapsulate all necessary data accesses for	* Small helper to encapsulate all necessary data accesses for
	* containers like vector, list, deque	* containers like vector, list, deque
	*	*
	* @author M.Frank	* @author M.Frank

	skipping to change at line 223	skipping to change at line 225
	* @date 10/10/2004	* @date 10/10/2004
	*/	*/
	template <class T> struct Pushback: public CollType<T> {	template <class T> struct Pushback: public CollType<T> {
	typedef T Cont_t;	typedef T Cont_t;
	typedef typename T::iterator Iter_t;	typedef typename T::iterator Iter_t;
	typedef typename T::value_type Value_t;	typedef typename T::value_type Value_t;
	typedef Environ<Iter_t> Env_t;	typedef Environ<Iter_t> Env_t;
	typedef Env_t* PEnv_t;	typedef Env_t* PEnv_t;
	typedef Cont_t* PCont_t;	typedef Cont_t* PCont_t;
	typedef Value_t* PValue_t;	typedef Value_t* PValue_t;

	static void*	static void resize(void* obj, size_t n) {
	resize(void* env) {	PCont_t c = PCont_t(obj);
	PEnv_t e = PEnv_t(env);	c->resize(n);
	PCont_t c = PCont_t(e->fObject);
	c->resize(e->fSize);
	e->fIdx = 0;
	return e->fStart = address(*c->begin());
	}	}

	static void*	static void*

	feed(void* env) {	feed(voidfrom,void to,size_t size) {
	PEnv_t e = PEnv_t(env);	PValue_t m = PValue_t(from);
	PCont_t c = PCont_t(e->fObject);	PCont_t c = PCont_t(to);
	PValue_t m = PValue_t(e->fStart);


	for (size_t i = 0; i < e->fSize; ++i, ++m) {	for (size_t i = 0; i < size; ++i, ++m) {
	c->push_back(*m);	c->push_back(*m);
	}	}
	return 0;	return 0;
	}	}

	static int	static int
	value_offset() {	value_offset() {
	return 0;	return 0;
	}	}


	skipping to change at line 268	skipping to change at line 265
	* @date 10/10/2004	* @date 10/10/2004
	*/	*/
	template <class T> struct Insert: public CollType<T> {	template <class T> struct Insert: public CollType<T> {
	typedef T Cont_t;	typedef T Cont_t;
	typedef typename T::iterator Iter_t;	typedef typename T::iterator Iter_t;
	typedef typename T::value_type Value_t;	typedef typename T::value_type Value_t;
	typedef Environ<Iter_t> Env_t;	typedef Environ<Iter_t> Env_t;
	typedef Env_t* PEnv_t;	typedef Env_t* PEnv_t;
	typedef Cont_t* PCont_t;	typedef Cont_t* PCont_t;
	typedef Value_t* PValue_t;	typedef Value_t* PValue_t;


	static void*	static void*

	feed(void* env) {	feed(voidfrom,voidto,size_t size) {
	PEnv_t e = PEnv_t(env);	PValue_t m = PValue_t(from);
	PCont_t c = PCont_t(e->fObject);	PCont_t c = PCont_t(to);
	PValue_t m = PValue_t(e->fStart);


	for (size_t i = 0; i < e->fSize; ++i, ++m) {	for (size_t i = 0; i < size; ++i, ++m) {
	c->insert(*m);	c->insert(*m);
	}	}
	return 0;	return 0;
	}	}


	static void*	static void resize(void* /* obj */, size_t) { }
	resize(void* /* env */) {
	return 0;
	}

	static int	static int
	value_offset() {	value_offset() {
	return 0;	return 0;
	}	}

	};	};

	/** @class TCollectionProxy::Map TCollectionProxy.h TCollectionProxy.h	/** @class TCollectionProxy::Map TCollectionProxy.h TCollectionProxy.h
	*	*

	skipping to change at line 309	skipping to change at line 303
	* @date 10/10/2004	* @date 10/10/2004
	*/	*/
	template <class T> struct MapInsert: public CollType<T> {	template <class T> struct MapInsert: public CollType<T> {
	typedef T Cont_t;	typedef T Cont_t;
	typedef typename T::iterator Iter_t;	typedef typename T::iterator Iter_t;
	typedef typename T::value_type Value_t;	typedef typename T::value_type Value_t;
	typedef Environ<Iter_t> Env_t;	typedef Environ<Iter_t> Env_t;
	typedef Env_t* PEnv_t;	typedef Env_t* PEnv_t;
	typedef Cont_t* PCont_t;	typedef Cont_t* PCont_t;
	typedef Value_t* PValue_t;	typedef Value_t* PValue_t;


	static void*	static void*

	feed(void* env) {	feed(voidfrom,void to,size_t size) {
	PEnv_t e = PEnv_t(env);	PValue_t m = PValue_t(from);
	PCont_t c = PCont_t(e->fObject);	PCont_t c = PCont_t(to);
	PValue_t m = PValue_t(e->fStart);


	for (size_t i = 0; i < e->fSize; ++i, ++m) {	for (size_t i = 0; i < size; ++i, ++m) {
	c->insert(*m);	c->insert(*m);
	}	}
	return 0;	return 0;
	}	}


	static void*	static void resize(void* /* obj */, size_t) {
	resize(void* /* env */) {
	return 0;
	}	}

	static int	static int
	value_offset() {	value_offset() {
	return ((char) &((PValue_t(0x1000))->second)) - ((char) PValue_t(0x 1000));	return ((char) &((PValue_t(0x1000))->second)) - ((char) PValue_t(0x 1000));
	}	}

	};	};

	#ifndef __CINT__	#ifndef __CINT__

	skipping to change at line 358	skipping to change at line 350
	* Table containing pointers to concrete functions to manipulate	* Table containing pointers to concrete functions to manipulate
	* Collections in a generic way	* Collections in a generic way
	*	*
	* @author M.Frank	* @author M.Frank
	*/	*/
	struct RFLX_API CollFuncTable {	struct RFLX_API CollFuncTable {
	size_t iter_size;	size_t iter_size;
	size_t value_diff;	size_t value_diff;
	int value_offset;	int value_offset;
	void* (size_func)(void);	void* (size_func)(void);

	void* (resize_func)(void);	void (resize_func)(void,size_t);
	void* (clear_func)(void);	void* (clear_func)(void);
	void* (first_func)(void);	void* (first_func)(void);
	void* (next_func)(void);	void* (next_func)(void);

	void* (construct_func)(void);	void* (construct_func)(void,size_t);
	void* (destruct_func)(void);	void (destruct_func)(void,size_t);
	void* (feed_func)(void);	void* (feed_func)(void,void*,size_t);
	void* (collect_func)(void);	void* (collect_func)(void);
	void* (*create_env)();	void* (*create_env)();
	};	};

	template <typename T> struct CFTGenerator {	template <typename T> struct CFTGenerator {
	static CollFuncTable*	static CollFuncTable*
	Generate() {	Generate() {
	typedef typename T::Value_t Value_t;	typedef typename T::Value_t Value_t;
	typedef std::pair<Value_t, Value_t> Pair_t;	typedef std::pair<Value_t, Value_t> Pair_t;
	Pair_t* ptr = (Pair_t*) 0x1000;	Pair_t* ptr = (Pair_t*) 0x1000;

	skipping to change at line 402	skipping to change at line 394
	};	};
	struct CFTNullGenerator {	struct CFTNullGenerator {
	static void*	static void*
	Void_func(void*) {	Void_func(void*) {
	return 0;	return 0;
	}	}

	static void*	static void*
	Void_func0() { return 0; }	Void_func0() { return 0; }


		static void
		Void_func2b(void*,size_t) { ; }

		static void*
		Void_func2(void*,size_t) { return 0; }

		static void*
		Void_func3(void,void,size_t) { return 0; }

	static CollFuncTable*	static CollFuncTable*
	Generate() {	Generate() {
	CollFuncTable* p = new CollFuncTable();	CollFuncTable* p = new CollFuncTable();
	p->iter_size = 4;	p->iter_size = 4;
	p->value_diff = 0;	p->value_diff = 0;
	p->value_offset = 0;	p->value_offset = 0;
	p->size_func = Void_func;	p->size_func = Void_func;
	p->first_func = Void_func;	p->first_func = Void_func;
	p->next_func = Void_func;	p->next_func = Void_func;
	p->clear_func = Void_func;	p->clear_func = Void_func;

	p->resize_func = Void_func;	p->resize_func = Void_func2b;
	p->collect_func = Void_func;	p->collect_func = Void_func;

	p->construct_func = Void_func;	p->construct_func = Void_func2;
	p->destruct_func = Void_func;	p->destruct_func = Void_func2b;
	p->feed_func = Void_func;	p->feed_func = Void_func3;
	p->create_env = Void_func0;	p->create_env = Void_func0;
	return p;	return p;
	} // Generate	} // Generate

	};	};
	// General proxy (dummy)	// General proxy (dummy)
	template <typename A> struct Proxy {};	template <typename A> struct Proxy {};

	// Specialization for std::vector	// Specialization for std::vector
	template <class T, class A> struct Proxy<std::vector<T, A> > {	template <class T, class A> struct Proxy<std::vector<T, A> > {

	skipping to change at line 615	skipping to change at line 616
	next(void* env) {	next(void* env) {
	PEnv_t e = PEnv_t(env);	PEnv_t e = PEnv_t(env);
	PCont_t c = PCont_t(e->fObject);	PCont_t c = PCont_t(e->fObject);

	for ( ; e->fIdx > 0 && e->fIterator.first != c->size(); ++(e->fIterat or.first), --e->fIdx) {}	for ( ; e->fIdx > 0 && e->fIterator.first != c->size(); ++(e->fIterat or.first), --e->fIdx) {}
	e->fIterator.second = (e->fIterator.first != c->size()) ? c->test(e-> fIterator.first) : false;	e->fIterator.second = (e->fIterator.first != c->size()) ? c->test(e-> fIterator.first) : false;
	return 0;	return 0;
	}	}

	static void*	static void*

	construct(void*) {	construct(void*,size_t) {
	// Nothing to construct.	// Nothing to construct.
	return 0;	return 0;
	}	}

	static void*	static void*
	collect(void* env) {	collect(void* env) {
	PEnv_t e = PEnv_t(env);	PEnv_t e = PEnv_t(env);
	PCont_t c = PCont_t(e->fObject);	PCont_t c = PCont_t(e->fObject);
	PValue_t m = PValue_t(e->fStart); // 'start' is a buffer outside t he container.	PValue_t m = PValue_t(e->fStart); // 'start' is a buffer outside t he container.

	for (size_t i = 0; i != c->size(); ++i, ++m) {	for (size_t i = 0; i != c->size(); ++i, ++m) {
	*m = c->test(i);	*m = c->test(i);
	}	}
	return 0;	return 0;
	}	}


	static void*	static void
	destruct(void*) {	destruct(void*,size_t) {
	// Nothing to destruct.	// Nothing to destruct.

	return 0;
	}	}

	};	};

	template <typename Bitset_t>	template <typename Bitset_t>
	struct Pushback<StdBitSetHelper<Bitset_t> > : public CollType<StdBitSetHelp er<Bitset_t> > {	struct Pushback<StdBitSetHelper<Bitset_t> > : public CollType<StdBitSetHelp er<Bitset_t> > {
	typedef Bitset_t Cont_t;	typedef Bitset_t Cont_t;
	typedef bool Iter_t;	typedef bool Iter_t;
	typedef bool Value_t;	typedef bool Value_t;
	typedef Environ<Iter_t> Env_t;	typedef Environ<Iter_t> Env_t;
	typedef Env_t* PEnv_t;	typedef Env_t* PEnv_t;
	typedef Cont_t* PCont_t;	typedef Cont_t* PCont_t;
	typedef Value_t* PValue_t;	typedef Value_t* PValue_t;


	static void*	static void resize(void* /obj/, size_t) { }
	resize(void* env) {
	PEnv_t e = PEnv_t(env);
	e->fIdx = 0;
	return 0;
	}

	static void*	static void*
	feed(void* env) {	feed(void* env) {
	PEnv_t e = PEnv_t(env);	PEnv_t e = PEnv_t(env);
	PCont_t c = PCont_t(e->fObject);	PCont_t c = PCont_t(e->fObject);
	PValue_t m = PValue_t(e->fStart); // Here start is actually a 'buf fer' outside the container.	PValue_t m = PValue_t(e->fStart); // Here start is actually a 'buf fer' outside the container.

	for (size_t i = 0; i < e->fSize; ++i, ++m) {	for (size_t i = 0; i < e->fSize; ++i, ++m) {
	c->set(i, *m);	c->set(i, *m);
	}	}
	return 0;	return 0;
	}	}


		static void*
		feed(void* from, void* to, size_t size) {
		PValue_t m = PValue_t(from);
		PCont_t c = PCont_t(to);

		for (size_t i = 0; i < size; ++i, ++m) {
		c->set(i, *m);
		}
		return 0;
		}

	static int	static int
	value_offset() {	value_offset() {
	return 0;	return 0;
	}	}

	};	};
	#endif	#endif

	template <typename B> struct Proxy<StdBitSetHelper<B> > {	template <typename B> struct Proxy<StdBitSetHelper<B> > {
	static CollFuncTable*	static CollFuncTable*

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

	CrossEntropy.h	CrossEntropy.h

	// @(#)root/tmva $Id: CrossEntropy.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: CrossEntropy.h 37399 2010-12-08 15:22:07Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : CrossEntropy *	* Class : CrossEntropy *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: Implementation of the CrossEntropy as separation criterion *	* Description: Implementation of the CrossEntropy as separation criterion *
	* *	* *

	skipping to change at line 50	skipping to change at line 50
	#include "TMVA/SeparationBase.h"	#include "TMVA/SeparationBase.h"
	#endif	#endif

	namespace TMVA {	namespace TMVA {

	class CrossEntropy : public SeparationBase {	class CrossEntropy : public SeparationBase {

	public:	public:

	// default constructor	// default constructor

	CrossEntropy() { fName = "CE"; }	CrossEntropy(): SeparationBase() { fName = "CE"; }

	// copy constructor	// copy constructor
	CrossEntropy( const CrossEntropy& g): SeparationBase(g) {}	CrossEntropy( const CrossEntropy& g): SeparationBase(g) {}

	// destructor	// destructor
	virtual ~CrossEntropy(){}	virtual ~CrossEntropy(){}

	// return the separation Index -p log (p) - (1-p)log(1-p); p=pur ity = s/(s+b)	// return the separation Index -p log (p) - (1-p)log(1-p); p=pur ity = s/(s+b)
	virtual Double_t GetSeparationIndex( const Double_t &s, const Double_ t &b );	virtual Double_t GetSeparationIndex( const Double_t &s, const Double_ t &b );


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

	DaemonUtils.h	DaemonUtils.h

	// @(#)root/auth:$Id: DaemonUtils.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/auth:$Id: DaemonUtils.h 36126 2010-10-06 15:14:52Z ganis $
	// Author: Gerri Ganis 19/1/2004	// Author: Gerri Ganis 19/1/2004

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2003, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2003, 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 44	skipping to change at line 44
	#endif	#endif
	#ifndef ROOT_rpddefs	#ifndef ROOT_rpddefs
	#include "rpddefs.h"	#include "rpddefs.h"
	#endif	#endif

	extern Int_t SrvAuthImpl(TSocket socket, const char , const char *,	extern Int_t SrvAuthImpl(TSocket socket, const char , const char *,
	std::string &user, Int_t &meth,	std::string &user, Int_t &meth,
	Int_t &type, std::string &ctoken, TSeqCollection * );	Int_t &type, std::string &ctoken, TSeqCollection * );
	extern Int_t SrvClupImpl(TSeqCollection *);	extern Int_t SrvClupImpl(TSeqCollection *);


	typedef void (ErrorHandler_t)(int level, const char msg);	typedef void (ErrorHandler_t)(int level, const char msg, int size);

	namespace ROOT {	namespace ROOT {

	// Error handlers prototypes ...	// Error handlers prototypes ...
	extern ErrorHandler_t gErrSys;	extern ErrorHandler_t gErrSys;
	extern ErrorHandler_t gErrFatal;	extern ErrorHandler_t gErrFatal;
	extern ErrorHandler_t gErr;	extern ErrorHandler_t gErr;

	int GetErrno();	int GetErrno();
	void ResetErrno();	void ResetErrno();
	void ErrorInit(const char *ident);	void ErrorInit(const char *ident);
	void ErrorInfo(const char *fmt, ...);	void ErrorInfo(const char *fmt, ...);

	void Perror(char *buf);	void Perror(char *buf, int size);
	void Error(ErrorHandler_t ErrHand,int code,const char *fmt, ...);	void Error(ErrorHandler_t ErrHand,int code,const char *fmt, ...);

	void RpdAuthCleanup(const char *sstr, int opt);	void RpdAuthCleanup(const char *sstr, int opt);
	int RpdCleanupAuthTab(const char *crypttoken);	int RpdCleanupAuthTab(const char *crypttoken);
	int RpdGenRSAKeys(int);	int RpdGenRSAKeys(int);
	void RpdSetErrorHandler(ErrorHandler_t Err, ErrorHandler_t Sys,	void RpdSetErrorHandler(ErrorHandler_t Err, ErrorHandler_t Sys,
	ErrorHandler_t Fatal);	ErrorHandler_t Fatal);
	void RpdSetMethInitFlag(int methinit);	void RpdSetMethInitFlag(int methinit);
	int RpdInitSession(int, std::string &, int &, int &, int &, std::string &) ;	int RpdInitSession(int, std::string &, int &, int &, int &, std::string &) ;
	void RpdInit(EService serv, int pid, int sproto,	void RpdInit(EService serv, int pid, int sproto,

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

	DataMbr.h	DataMbr.h

	skipping to change at line 19	skipping to change at line 19
	************************************************************************	************************************************************************
	* Copyright(c) 1995~1998 Masaharu Goto	* Copyright(c) 1995~1998 Masaharu Goto
	*	*
	* For the licensing terms see the file COPYING	* For the licensing terms see the file COPYING
	*	*
	************************************************************************/	************************************************************************/

	#ifndef G__DATAMEMBER_H	#ifndef G__DATAMEMBER_H
	#define G__DATAMEMBER_H	#define G__DATAMEMBER_H


		#ifndef G__API_H
	#include "Api.h"	#include "Api.h"

		#endif

	namespace Cint {	namespace Cint {

	/*********************************************************************	/*********************************************************************
	* class G__DataMemberInfo	* class G__DataMemberInfo
	*	*
	*	*
	*********************************************************************/	*********************************************************************/
	class	class
	#ifndef __CINT__	#ifndef __CINT__

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

	DataSet.h	DataSet.h

	// @(#)root/tmva $Id: DataSet.h 33928 2010-06-15 16:19:31Z stelzer $	// @(#)root/tmva $Id: DataSet.h 37399 2010-12-08 15:22:07Z evt $
	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : DataSet *	* Class : DataSet *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Contains all the data information *	* Contains all the data information *

	skipping to change at line 122	skipping to change at line 122
	Long64_t GetNEvtSigTest();	Long64_t GetNEvtSigTest();
	Long64_t GetNEvtBkgdTest();	Long64_t GetNEvtBkgdTest();
	Long64_t GetNEvtSigTrain();	Long64_t GetNEvtSigTrain();
	Long64_t GetNEvtBkgdTrain();	Long64_t GetNEvtBkgdTrain();

	Bool_t HasNegativeEventWeights() const { return fHasNegativeEventW eights; }	Bool_t HasNegativeEventWeights() const { return fHasNegativeEventW eights; }

	Results* GetResults ( const TString &,	Results* GetResults ( const TString &,
	Types::ETreeType type,	Types::ETreeType type,
	Types::EAnalysisType analysistype );	Types::EAnalysisType analysistype );

		void DeleteResults ( const TString &,
		Types::ETreeType type,
		Types::EAnalysisType analysistype );

	void SetVerbose( Bool_t ) {}	void SetVerbose( Bool_t ) {}

	// sets the number of blocks to which the training set is divided,	// sets the number of blocks to which the training set is divided,
	// some of which are given to the Validation sample. As default they belong all to Training set.	// some of which are given to the Validation sample. As default they belong all to Training set.
	void DivideTrainingSet( UInt_t blockNum );	void DivideTrainingSet( UInt_t blockNum );

	// sets a certrain block from the origin training set to belong to ei ther Training or Validation set	// sets a certrain block from the origin training set to belong to ei ther Training or Validation set
	void MoveTrainingBlock( Int_t blockInd,Types::ETreeType dest, Bo ol_t applyChanges = kTRUE );	void MoveTrainingBlock( Int_t blockInd,Types::ETreeType dest, Bo ol_t applyChanges = kTRUE );


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

	DecisionTreeNode.h	DecisionTreeNode.h

	// @(#)root/tmva $Id: DecisionTreeNode.h 35730 2010-09-25 10:59:13Z stelzer $	// @(#)root/tmva $Id: DecisionTreeNode.h 37399 2010-12-08 15:22:07Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss, Eckhard vo n Toerne	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss, Eckhard vo n Toerne

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : DecisionTreeNode *	* Class : DecisionTreeNode *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Node for the Decision Tree *	* Node for the Decision Tree *

	skipping to change at line 49	skipping to change at line 49
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TMVA_Node	#ifndef ROOT_TMVA_Node
	#include "TMVA/Node.h"	#include "TMVA/Node.h"
	#endif	#endif

	#ifndef ROOT_TMVA_Version	#ifndef ROOT_TMVA_Version
	#include "TMVA/Version.h"	#include "TMVA/Version.h"
	#endif	#endif


		#include <iostream>
	#include <vector>	#include <vector>
	#include <map>	#include <map>
	namespace TMVA {	namespace TMVA {

	class DTNodeTrainingInfo	class DTNodeTrainingInfo
	{	{
	public:	public:
	DTNodeTrainingInfo():fSampleMin(),	DTNodeTrainingInfo():fSampleMin(),
	fSampleMax(),	fSampleMax(),
	fNodeR(0),fSubTreeR(0),fAlpha(0),fG(0),fNTermina l(0),	fNodeR(0),fSubTreeR(0),fAlpha(0),fG(0),fNTermina l(0),

	skipping to change at line 125	skipping to change at line 126
	public:	public:

	// constructor of an essentially "empty" node floating in space	// constructor of an essentially "empty" node floating in space
	DecisionTreeNode ();	DecisionTreeNode ();
	// constructor of a daughter node as a daughter of 'p'	// constructor of a daughter node as a daughter of 'p'
	DecisionTreeNode (Node* p, char pos);	DecisionTreeNode (Node* p, char pos);

	// copy constructor	// copy constructor
	DecisionTreeNode (const DecisionTreeNode &n, DecisionTreeNode* parent = NULL);	DecisionTreeNode (const DecisionTreeNode &n, DecisionTreeNode* parent = NULL);


		// destructor
	virtual ~DecisionTreeNode();	virtual ~DecisionTreeNode();

	virtual Node* CreateNode() const { return new DecisionTreeNode(); }	virtual Node* CreateNode() const { return new DecisionTreeNode(); }


		inline void SetNFisherCoeff(Int_t nvars){fFisherCoeff.resize(nvars);}
		inline UInt_t GetNFisherCoeff() const { return fFisherCoeff.size();}
		// set fisher coefficients
		void SetFisherCoeff(Int_t ivar, Double_t coeff);
		// get fisher coefficients
		Double_t GetFisherCoeff(Int_t ivar) const {return fFisherCoeff.at(iva
		r);}

	// test event if it decends the tree at this node to the right	// test event if it decends the tree at this node to the right
	virtual Bool_t GoesRight( const Event & ) const;	virtual Bool_t GoesRight( const Event & ) const;

	// test event if it decends the tree at this node to the left	// test event if it decends the tree at this node to the left
	virtual Bool_t GoesLeft ( const Event & ) const;	virtual Bool_t GoesLeft ( const Event & ) const;

	// set index of variable used for discrimination at this node	// set index of variable used for discrimination at this node
	void SetSelector( Short_t i) { fSelector = i; }	void SetSelector( Short_t i) { fSelector = i; }
	// return index of variable used for discrimination at this node	// return index of variable used for discrimination at this node
	Short_t GetSelector() const { return fSelector; }	Short_t GetSelector() const { return fSelector; }

	skipping to change at line 249	skipping to change at line 258
	// recursively print the node and its daughters (--> print the 'tree' )	// recursively print the node and its daughters (--> print the 'tree' )
	virtual void PrintRec( ostream& os ) const;	virtual void PrintRec( ostream& os ) const;

	virtual void AddAttributesToNode(void* node) const;	virtual void AddAttributesToNode(void* node) const;
	virtual void AddContentToNode(std::stringstream& s) const;	virtual void AddContentToNode(std::stringstream& s) const;

	// recursively clear the nodes content (S/N etc, but not the cut crit eria)	// recursively clear the nodes content (S/N etc, but not the cut crit eria)
	void ClearNodeAndAllDaughters();	void ClearNodeAndAllDaughters();

	// get pointers to children, mother in the tree	// get pointers to children, mother in the tree

	inline DecisionTreeNode* GetLeftDaughter( ) { return dynamic_cast<Dec
	isionTreeNode*>(GetLeft()); }
	inline DecisionTreeNode* GetRightDaughter( ) { return dynamic_cast<De
	cisionTreeNode*>(GetRight()); }
	inline DecisionTreeNode* GetMother( ) { return dynamic_cast<DecisionT
	reeNode*>(GetParent()); }
	inline const DecisionTreeNode* GetLeftDaughter( ) const { return dyna
	mic_cast<DecisionTreeNode*>(GetLeft()); }
	inline const DecisionTreeNode* GetRightDaughter( ) const { return dyn
	amic_cast<DecisionTreeNode*>(GetRight()); }
	inline const DecisionTreeNode* GetMother( ) const { return dynamic_ca
	st<DecisionTreeNode*>(GetParent()); }

	ULong_t GetSequence() const {return fSequence;}


	void SetSequence(ULong_t s) {fSequence=s;}	// return pointer to the left/right daughter or parent node
		inline virtual DecisionTreeNode* GetLeft( ) const { return dynamic_
		cast<DecisionTreeNode*>(fLeft); }
		inline virtual DecisionTreeNode* GetRight( ) const { return dynamic_
		cast<DecisionTreeNode*>(fRight); }
		inline virtual DecisionTreeNode* GetParent( ) const { return dynamic_
		cast<DecisionTreeNode*>(fParent); }

		// set pointer to the left/right daughter and parent node
		inline virtual void SetLeft (Node* l) { fLeft = dynamic_cast<Decis
		ionTreeNode*>(l);}
		inline virtual void SetRight (Node* r) { fRight = dynamic_cast<Decis
		ionTreeNode*>(r);}
		inline virtual void SetParent(Node* p) { fParent = dynamic_cast<Decis
		ionTreeNode*>(p);}

	// the node resubstitution estimate, R(t), for Cost Complexity prunin g	// the node resubstitution estimate, R(t), for Cost Complexity prunin g
	inline void SetNodeR( Double_t r ) { fTrainInfo->fNodeR = r; }	inline void SetNodeR( Double_t r ) { fTrainInfo->fNodeR = r; }
	inline Double_t GetNodeR( ) const { return fTrainInfo->fNodeR; }	inline Double_t GetNodeR( ) const { return fTrainInfo->fNodeR; }

	// the resubstitution estimate, R(T_t), of the tree rooted at this no de	// the resubstitution estimate, R(T_t), of the tree rooted at this no de
	inline void SetSubTreeR( Double_t r ) { fTrainInfo->fSubTreeR = r; }	inline void SetSubTreeR( Double_t r ) { fTrainInfo->fSubTreeR = r; }
	inline Double_t GetSubTreeR( ) const { return fTrainInfo->fSubTreeR; }	inline Double_t GetSubTreeR( ) const { return fTrainInfo->fSubTreeR; }

	// R(t) - R(T_t)	// R(t) - R(T_t)

	skipping to change at line 316	skipping to change at line 325
	void SetCC(Double_t cc);	void SetCC(Double_t cc);
	Double_t GetCC() const {return (fTrainInfo? fTrainInfo->fCC : -1.);}	Double_t GetCC() const {return (fTrainInfo? fTrainInfo->fCC : -1.);}

	Float_t GetSampleMin(UInt_t ivar) const;	Float_t GetSampleMin(UInt_t ivar) const;
	Float_t GetSampleMax(UInt_t ivar) const;	Float_t GetSampleMax(UInt_t ivar) const;
	void SetSampleMin(UInt_t ivar, Float_t xmin);	void SetSampleMin(UInt_t ivar, Float_t xmin);
	void SetSampleMax(UInt_t ivar, Float_t xmax);	void SetSampleMax(UInt_t ivar, Float_t xmax);

	static bool fgIsTraining; // static variable to flag training phase i n which we need fTrainInfo	static bool fgIsTraining; // static variable to flag training phase i n which we need fTrainInfo


	private:	protected:


	virtual void ReadAttributes(void* node, UInt_t tmva_Version_Code = TM	static MsgLogger* fgLogger; // static because there is a huge numb
	VA_VERSION_CODE );	er of nodes...
	virtual Bool_t ReadDataRecord( istream& is, UInt_t tmva_Version_Code
	= TMVA_VERSION_CODE );	std::vector<Double_t> fFisherCoeff; // the other fisher coef
	virtual void ReadContent(std::stringstream& s);	f (offset at the last element

	Float_t fCutValue; // cut value appplied on this node to disc riminate bkg against sig	Float_t fCutValue; // cut value appplied on this node to disc riminate bkg against sig
	Bool_t fCutType; // true: if event variable > cutValue ==> signal , false otherwise	Bool_t fCutType; // true: if event variable > cutValue ==> signal , false otherwise
	Short_t fSelector; // index of variable used in node selectio n (decision tree)	Short_t fSelector; // index of variable used in node selectio n (decision tree)

	Float_t fResponse; // response value in case of regression	Float_t fResponse; // response value in case of regression
	Float_t fRMS; // response RMS of the regression node	Float_t fRMS; // response RMS of the regression node
	Int_t fNodeType; // Type of node: -1 == Bkg-leaf, 1 == Sign al-leaf, 0 = internal	Int_t fNodeType; // Type of node: -1 == Bkg-leaf, 1 == Sign al-leaf, 0 = internal
	Float_t fPurity; // the node purity	Float_t fPurity; // the node purity


	ULong_t fSequence; // bit coded left right sequence to reach
	the node

	Bool_t fIsTerminalNode; //! flag to set node as terminal (i.e., without deleting its descendants)	Bool_t fIsTerminalNode; //! flag to set node as terminal (i.e., without deleting its descendants)


	static MsgLogger* fgLogger; // static because there is a huge numb er of nodes...
	mutable DTNodeTrainingInfo* fTrainInfo;	mutable DTNodeTrainingInfo* fTrainInfo;


	ClassDef(DecisionTreeNode,0) // Node for the Decision Tree	private:


	};	virtual void ReadAttributes(void* node, UInt_t tmva_Version_Code = TM
		VA_VERSION_CODE );
		virtual Bool_t ReadDataRecord( istream& is, UInt_t tmva_Version_Code
		= TMVA_VERSION_CODE );
		virtual void ReadContent(std::stringstream& s);

		ClassDef(DecisionTreeNode,0) // Node for the Decision Tree
		};
	} // namespace TMVA	} // namespace TMVA

	#endif	#endif

End of changes. 12 change blocks.
	28 lines changed or deleted	41 lines changed or added

	DistSampler.h	DistSampler.h

	// @(#)root/mathcore:$Id: DistSampler.h 34077 2010-06-23 10:09:18Z moneta $	// @(#)root/mathcore:$Id: DistSampler.h 37371 2010-12-07 16:26:39Z moneta $
	// Author: L. Moneta Fri Sep 22 15:06:47 2006	// Author: L. Moneta Fri Sep 22 15:06:47 2006

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for class DistSampler	// Header file for class DistSampler

	skipping to change at line 40	skipping to change at line 40

	namespace Fit {	namespace Fit {

	class DataRange;	class DataRange;
	class BinData;	class BinData;
	class UnBinData;	class UnBinData;
	}	}

	namespace Math {	namespace Math {


		class DistSamplerOptions;

	/**	/**
	@defgroup Random Random number generators and generation of random numbe r distributions	@defgroup Random Random number generators and generation of random numbe r distributions
	@ingroup Random	@ingroup Random

	Classes implementing random number generators and classes implementing g eneration of random numbers	Classes implementing random number generators and classes implementing g eneration of random numbers
	according to arbitrary distributions	according to arbitrary distributions
	*/	*/

	//_________________________________________________________________________ ______	//_________________________________________________________________________ ______
	/**	/**

	skipping to change at line 92	skipping to change at line 94
	DoSetFunction(func,false);	DoSetFunction(func,false);
	}	}

	/// return the dimension of the parent distribution (and the data)	/// return the dimension of the parent distribution (and the data)
	unsigned int NDim() const { return fData.size(); }	unsigned int NDim() const { return fData.size(); }

	/**	/**
	initialize the generators with the given algorithm	initialize the generators with the given algorithm
	Implemented by derived classes who needs it	Implemented by derived classes who needs it
	(like UnuranSampler)	(like UnuranSampler)

		If nothing is specified use default algorithm
		from DistSamplerOptions::SetDefaultAlgorithm
		*/
		virtual bool Init(const char * =""/* algorithm */) { return true;}

		/**
		initialize the generators with the given option
		which my include the algorithm but also more if
		the method is re-impelmented by derived class
		The default implementation calls the above method
		passing just the algorithm name
	*/	*/

	virtual bool Init(const char * /* algorithm */) { return true;}	virtual bool Init(const DistSamplerOptions & opt );

	/**	/**
	Set the random engine to be used	Set the random engine to be used
	To be implemented by the derived classes who provides	To be implemented by the derived classes who provides
	random sampling	random sampling
	*/	*/
	virtual void SetRandom(TRandom * ) {}	virtual void SetRandom(TRandom * ) {}

	/**	/**
	Set the random seed for the TRandom instances used by the sampler	Set the random seed for the TRandom instances used by the sampler

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

	Event.h	Event.h

	// @(#)root/tmva $Id: Event.h 33928 2010-06-15 16:19:31Z stelzer $	// @(#)root/tmva $Id: Event.h 37399 2010-12-08 15:22:07Z evt $
	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : Event *	* Class : Event *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Event container *	* Event container *

	skipping to change at line 63	skipping to change at line 63
	friend std::ostream& operator<<( std::ostream& os, const Event& event );	friend std::ostream& operator<<( std::ostream& os, const Event& event );

	public:	public:

	// constructors	// constructors
	Event();	Event();
	Event( const Event& );	Event( const Event& );
	explicit Event( const std::vector<Float_t>& values,	explicit Event( const std::vector<Float_t>& values,
	const std::vector<Float_t>& targetValues,	const std::vector<Float_t>& targetValues,
	const std::vector<Float_t>& spectatorValues,	const std::vector<Float_t>& spectatorValues,

	UInt_t theClass = 0, Float_t weight = 1.0, Float_t bo ostweight = 1.0 );	UInt_t theClass = 0, Double_t weight = 1.0, Double_t boostweight = 1.0 );
	explicit Event( const std::vector<Float_t>& values,	explicit Event( const std::vector<Float_t>& values,
	const std::vector<Float_t>& targetValues,	const std::vector<Float_t>& targetValues,

	UInt_t theClass = 0, Float_t weight = 1.0, Float_t bo ostweight = 1.0 );	UInt_t theClass = 0, Double_t weight = 1.0, Double_t boostweight = 1.0 );
	explicit Event( const std::vector<Float_t>&,	explicit Event( const std::vector<Float_t>&,

	UInt_t theClass, Float_t weight = 1.0, Float_t boostw eight = 1.0 );	UInt_t theClass, Double_t weight = 1.0, Double_t boos tweight = 1.0 );
	explicit Event( const std::vector<Float_t>&, UInt_t nvar );	explicit Event( const std::vector<Float_t>&, UInt_t nvar );

	~Event();	~Event();

	// accessors	// accessors
	Bool_t IsDynamic() const {return fDynamic; }	Bool_t IsDynamic() const {return fDynamic; }


	Float_t GetWeight() const { return fWeight*fBoostWeight; }	Double_t GetWeight() const { return fWeight*fBoostWeight; }
	Float_t GetOriginalWeight() const { return fWeight; }	Double_t GetOriginalWeight() const { return fWeight; }
	Float_t GetBoostWeight() const { return TMath::Max(Float_t(0.0001)	Double_t GetBoostWeight() const { return TMath::Max(Double_t(0.000
	,fBoostWeight); }	1),fBoostWeight); }
	UInt_t GetClass() const { return fClass; }	UInt_t GetClass() const { return fClass; }

	UInt_t GetNVariables() const;	UInt_t GetNVariables() const;
	UInt_t GetNTargets() const;	UInt_t GetNTargets() const;
	UInt_t GetNSpectators() const;	UInt_t GetNSpectators() const;

	const std::vector<UInt_t>* GetVariableArrangement() const { return fV ariableArrangement; }	const std::vector<UInt_t>* GetVariableArrangement() const { return fV ariableArrangement; }

	Float_t GetValue( UInt_t ivar) const;	Float_t GetValue( UInt_t ivar) const;
	const std::vector<Float_t>& GetValues() const;	const std::vector<Float_t>& GetValues() const;

	Float_t GetTarget( UInt_t itgt ) const { return fTargets.at(itgt); }	Float_t GetTarget( UInt_t itgt ) const { return fTargets.at(itgt); }
	std::vector<Float_t>& GetTargets() const { return fTargets; }	std::vector<Float_t>& GetTargets() const { return fTargets; }

	Float_t GetSpectator( UInt_t ivar) const;	Float_t GetSpectator( UInt_t ivar) const;
	std::vector<Float_t>& GetSpectators() const { return fSpectators; }	std::vector<Float_t>& GetSpectators() const { return fSpectators; }


	void ScaleWeight ( Float_t s ) { fWeight*=s; }	void ScaleWeight ( Double_t s ) { fWeight*=s; }
	void SetWeight ( Float_t w ) { fWeight=w; }	void SetWeight ( Double_t w ) { fWeight=w; }
	void SetBoostWeight ( Float_t w ) { fBoostWeight=w; }	void SetBoostWeight ( Double_t w ) { fBoostWeight=w; }
	void ScaleBoostWeight ( Float_t s ) { fBoostWeight *= s; }	void ScaleBoostWeight ( Double_t s ) { fBoostWeight *= s; }
	void SetClass ( UInt_t t ) { fClass=t; }	void SetClass ( UInt_t t ) { fClass=t; }
	void SetVal ( UInt_t ivar, Float_t val );	void SetVal ( UInt_t ivar, Float_t val );
	void SetTarget ( UInt_t itgt, Float_t value );	void SetTarget ( UInt_t itgt, Float_t value );
	void SetSpectator ( UInt_t ivar, Float_t value );	void SetSpectator ( UInt_t ivar, Float_t value );
	void SetVariableArrangement( std::vector<UInt_t>* const m ) const;	void SetVariableArrangement( std::vector<UInt_t>* const m ) const;

	static void ClearDynamicVariables();	static void ClearDynamicVariables();

	void CopyVarValues( const Event& other );	void CopyVarValues( const Event& other );
	void Print ( std::ostream & o ) const;	void Print ( std::ostream & o ) const;

	private:	private:

	mutable std::vector<Float_t> fValues; // the event va lues	mutable std::vector<Float_t> fValues; // the event va lues

	static std::vector<Float_t> fgValuesDynamic; // the event va lues	mutable std::vector<Float_t> fValuesDynamic; // the event val ues
	mutable std::vector<Float_t> fTargets; // target value s for regression	mutable std::vector<Float_t> fTargets; // target value s for regression
	mutable std::vector<Float_t> fSpectators; // "visisting" variables which are never used for any calculation	mutable std::vector<Float_t> fSpectators; // "visisting" variables which are never used for any calculation
	mutable std::vector<UInt_t>* fVariableArrangement; // needed for M ethodCategories, where we can train on other than the main variables	mutable std::vector<UInt_t>* fVariableArrangement; // needed for M ethodCategories, where we can train on other than the main variables

	UInt_t fClass; // signal or backgro und type: signal=1, background=0	UInt_t fClass; // signal or backgro und type: signal=1, background=0

	Float_t fWeight; // event weight (pro	Double_t fWeight; // event weight (pro
	duct of global and individual weights)	duct of global and individual weights)
	Float_t fBoostWeight; // internal weight t	Double_t fBoostWeight; // internal weight t
	o be set by boosting algorithm	o be set by boosting algorithm
	Bool_t fDynamic; // is set when the d ynamic values are taken	Bool_t fDynamic; // is set when the d ynamic values are taken


	static Int_t fgCount; // count instances o
	f Event
	};	};
	}	}

	#endif	#endif

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

	Factory.h	Factory.h

	// @(#)root/mathcore:$Id: Factory.h 33180 2010-04-25 10:14:07Z moneta $	// @(#)root/tmva $Id: Factory.h 37535 2010-12-10 22:40:29Z evt $
	// Author: L. Moneta Fri Dec 22 14:43:33 2006	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss, Ka
		i Voss


	/**********************************************************************	/**************************************************************************
	* *	********
	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis
	* *	*
	* *	* Package: TMVA
	**********************************************************************/	*
		* Class : Factory
	// Header file for class Factory	*
		* Web : http://tmva.sourceforge.net
	#ifndef ROOT_Math_Factory	*
	#define ROOT_Math_Factory	*
		*
		* Description:
		*
		* This is the main MVA steering class: it creates (books) all MVA met
		hods, *
		* and guides them through the training, testing and evaluation phases
		. *
		*
		*
		* Authors (alphabetical):
		*
		* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland
		*
		* Joerg Stelzer <stelzer@cern.ch> - DESY, Germany
		*
		* Peter Speckmayer <peter.speckmayer@cern.ch> - CERN, Switzerland
		*
		* Helge Voss <Helge.Voss@cern.ch> - MPI-K Heidelberg, German
		y *
		* Kai Voss <Kai.Voss@cern.ch> - U. of Victoria, Canada
		*
		*
		*
		* Copyright (c) 2005:
		*
		* CERN, Switzerland
		*
		* U. of Victoria, Canada
		*
		* MPI-K Heidelberg, Germany
		*
		*
		*
		* Redistribution and use in source and binary forms, with or without
		*
		* modification, are permitted according to the terms listed in LICENSE
		*
		* (http://tmva.sourceforge.net/LICENSE)
		*
		**************************************************************************
		********/

		#ifndef ROOT_TMVA_Factory
		#define ROOT_TMVA_Factory

		//////////////////////////////////////////////////////////////////////////
		// //
		// Factory //
		// //
		// This is the main MVA steering class: it creates all MVA methods, //
		// and guides them through the training, testing and evaluation //
		// phases //
		// //
		//////////////////////////////////////////////////////////////////////////

	#include <string>	#include <string>

		#include <vector>
		#include <map>
		#ifndef ROOT_TCut
		#include "TCut.h"
		#endif

		#ifndef ROOT_TMVA_Configurable
		#include "TMVA/Configurable.h"
		#endif
		#ifndef ROOT_TMVA_Types
		#include "TMVA/Types.h"
		#endif
		#ifndef ROOT_TMVA_DataSet
		#include "TMVA/DataSet.h"
		#endif

		class TFile;
		class TTree;
		class TDirectory;

		namespace TMVA {

		class IMethod;
		class MethodBase;
		class DataInputHandler;
		class DataSetInfo;
		class DataSetManager;
		class VariableTransformBase;

		class Factory : public Configurable {
		public:

		typedef std::vector<IMethod*> MVector;

		// no default constructor
		Factory( TString theJobName, TFile* theTargetFile, TString theOption
		= "" );

		// default destructor
		virtual ~Factory();

		virtual const char* GetName() const { return "Factory"; }

		// add events to training and testing trees
		void AddSignalTrainingEvent ( const std::vector<Double_t>& event,
		Double_t weight = 1.0 );
		void AddBackgroundTrainingEvent( const std::vector<Double_t>& event,
		Double_t weight = 1.0 );
		void AddSignalTestEvent ( const std::vector<Double_t>& event,
		Double_t weight = 1.0 );
		void AddBackgroundTestEvent ( const std::vector<Double_t>& event,
		Double_t weight = 1.0 );
		void AddTrainingEvent( const TString& className, const std::vector<Do
		uble_t>& event, Double_t weight );
		void AddTestEvent ( const TString& className, const std::vector<Do
		uble_t>& event, Double_t weight );
		void AddEvent ( const TString& className, Types::ETreeType tt,
		const std::vector<Double_t>& event, Double_t weight );
		Bool_t UserAssignEvents(UInt_t clIndex);
		TTree* CreateEventAssignTrees( const TString& name );

		DataSetInfo& AddDataSet( DataSetInfo& );
		DataSetInfo& AddDataSet( const TString& );

		// special case: signal/background

		// Data input related
		void SetInputTrees( const TString& signalFileName, const TString& bac
		kgroundFileName,
		Double_t signalWeight=1.0, Double_t backgroundWei
		ght=1.0 );
		void SetInputTrees( TTree* inputTree, const TCut& SigCut, const TCut&
		BgCut );
		// Set input trees at once
		void SetInputTrees( TTree* signal, TTree* background,
		Double_t signalWeight=1.0, Double_t backgroundWei
		ght=1.0) ;

		void AddSignalTree( TTree* signal, Double_t weight=1.0, Types::ETr
		eeType treetype = Types::kMaxTreeType );
		void AddSignalTree( TString datFileS, Double_t weight=1.0, Types::ETr
		eeType treetype = Types::kMaxTreeType );
		void AddSignalTree( TTree* signal, Double_t weight, const TString& tr
		eetype );

		// ... depreciated, kept for backwards compatibility
		void SetSignalTree( TTree* signal, Double_t weight=1.0);

		void AddBackgroundTree( TTree* background, Double_t weight=1.0, Types
		::ETreeType treetype = Types::kMaxTreeType );
		void AddBackgroundTree( TString datFileB, Double_t weight=1.0, Types
		::ETreeType treetype = Types::kMaxTreeType );
		void AddBackgroundTree( TTree* background, Double_t weight, const TSt
		ring & treetype );

		// ... depreciated, kept for backwards compatibility
		void SetBackgroundTree( TTree* background, Double_t weight=1.0 );

		void SetSignalWeightExpression( const TString& variable );
		void SetBackgroundWeightExpression( const TString& variable );

		// special case: regression
		void AddRegressionTree( TTree* tree, Double_t weight = 1.0,
		Types::ETreeType treetype = Types::kMaxTreeTy
		pe ) {
		AddTree( tree, "Regression", weight, "", treetype );
		}

		// general

		// Data input related
		void SetTree( TTree* tree, const TString& className, Double_t weight
		); // depreciated
		void AddTree( TTree* tree, const TString& className, Double_t weight=
		1.0,
		const TCut& cut = "",
		Types::ETreeType tt = Types::kMaxTreeType );
		void AddTree( TTree* tree, const TString& className, Double_t weight,
		const TCut& cut, const TString& treeType );

		// set input variable
		void SetInputVariables ( std::vector<TString>* theVariables ); // de
		preciated
		void AddVariable ( const TString& expression, const TString& t
		itle, const TString& unit,
		char type='F', Double_t min = 0, Double_t m
		ax = 0 );
		void AddVariable ( const TString& expression, char type='F',
		Double_t min = 0, Double_t max = 0 );
		void AddTarget ( const TString& expression, const TString& t
		itle = "", const TString& unit = "",
		Double_t min = 0, Double_t max = 0 );
		void AddRegressionTarget( const TString& expression, const TString& t
		itle = "", const TString& unit = "",
		Double_t min = 0, Double_t max = 0 )
		{
		AddTarget( expression, title, unit, min, max );
		}
		void AddSpectator ( const TString& expression, const TString&
		title = "", const TString& unit = "",
		Double_t min = 0, Double_t max = 0 );

		// set weight for class
		void SetWeightExpression( const TString& variable, const TString& cla
		ssName = "" );

		// set cut for class
		void SetCut( const TString& cut, const TString& className = "" );
		void SetCut( const TCut& cut, const TString& className = "" );
		void AddCut( const TString& cut, const TString& className = "" );
		void AddCut( const TCut& cut, const TString& className = "" );

		// prepare input tree for training
		void PrepareTrainingAndTestTree( const TCut& cut, const TString& spli
		tOpt );
		void PrepareTrainingAndTestTree( TCut sigcut, TCut bkgcut, const TStr
		ing& splitOpt );

		// ... deprecated, kept for backwards compatibility
		void PrepareTrainingAndTestTree( const TCut& cut, Int_t Ntrain, Int_t
		Ntest = -1 );

		void PrepareTrainingAndTestTree( const TCut& cut, Int_t NsigTrain, In
		t_t NbkgTrain, Int_t NsigTest, Int_t NbkgTest,
		const TString& otherOpt="SplitMode=R
		andom:!V" );

		MethodBase* BookMethod( TString theMethodName, TString methodTitle, T
		String theOption = "" );
		MethodBase* BookMethod( Types::EMVA theMethod, TString methodTitle,
		TString theOption = "" );
		MethodBase* BookMethod( TMVA::Types::EMVA /theMethod/,
		TString /methodTitle/,
		TString /methodOption/,
		TMVA::Types::EMVA /theCommittee/,
		TString /committeeOption = ""/ ) { return 0
		; }

		// optimize all booked methods (well, if desired by the method)
		void OptimizeAllMethods (TString fomType="ROCIntegral
		", TString fitType="FitGA");
		void OptimizeAllMethodsForClassification(TString fomType="ROCIntegral
		", TString fitType="FitGA") { OptimizeAllMethods(fomType,fitType); }
		void OptimizeAllMethodsForRegression (TString fomType="ROCIntegral
		", TString fitType="FitGA") { OptimizeAllMethods(fomType,fitType); }

		// training for all booked methods
		void TrainAllMethods ();
		void TrainAllMethodsForClassification( void ) { TrainAllMethods(); }
		void TrainAllMethodsForRegression ( void ) { TrainAllMethods(); }

		// testing
		void TestAllMethods();

		// performance evaluation
		void EvaluateAllMethods( void );
		void EvaluateAllVariables( TString options = "" );

		// delete all methods and reset the method vector
		void DeleteAllMethods( void );

		// accessors
		IMethod* GetMethod( const TString& title ) const;

		Bool_t Verbose( void ) const { return fVerbose; }
		void SetVerbose( Bool_t v=kTRUE );

		// make ROOT-independent C++ class for classifier response
		// (classifier-specific implementation)
		// If no classifier name is given, help messages for all booked
		// classifiers are printed
		virtual void MakeClass( const TString& methodTitle = "" ) const;

		// prints classifier-specific hepl messages, dedicated to
		// help with the optimisation and configuration options tuning.
		// If no classifier name is given, help messages for all booked
		// classifiers are printed
		void PrintHelpMessage( const TString& methodTitle = "" ) const;

		static TDirectory* RootBaseDir() { return (TDirectory*)fgTargetFile;
		}

		private:

		// the beautiful greeting message
		void Greetings();

		void WriteDataInformation();

		DataInputHandler& DataInput() { return *fDataInputHandler; }
		DataSetInfo& DefaultDataSetInfo();
		void SetInputTreesFromEventAssignTrees();

		private:

		// data members

		DataSetManager* fDataSetManager; // DSMTEST

		static TFile* fgTargetFile; //! ROOT
		output file

		DataInputHandler* fDataInputHandler;

		std::vector<TMVA::VariableTransformBase*> fDefaultTrfs; //! list
		of transformations on default DataSet

		// cd to local directory
		TString fOptions; //! optio
		n string given by construction (presently only "V")
		TString fTransformations; //! List
		of transformations to test
		Bool_t fVerbose; //! verbo
		se mode

		MVector fMethods; //! all M
		VA methods
		TString fJobName; //! jobna
		me, used as extension in weight file names

		// flag determining the way training and test data are assigned to Fa
		ctory
		enum DataAssignType { kUndefined = 0,
		kAssignTrees,
		kAssignEvents };
		DataAssignType fDataAssignType; //! flags
		for data assigning
		std::vector<TTree*> fTrainAssignTree; //! for e
		ach class: tmp tree if user wants to assign the events directly
		std::vector<TTree*> fTestAssignTree; //! for e
		ach class: tmp tree if user wants to assign the events directly

		Int_t fATreeType; // typ
		e of event (=classIndex)
		Float_t fATreeWeight; // wei
		ght of the event
		Float_t* fATreeEvent; // eve
		nt variables

		Types::EAnalysisType fAnalysisType; //! the t
		raining type


	namespace ROOT {	protected:

	namespace Math {

	class Minimizer;
	class DistSampler;

	//_________________________________________________________________________
	__
	/**
	Factory class holding static functions to create the interfaces like RO
	OT::Math::Minimizer
	via the Plugin Manager
	*/
	class Factory {
	public:

	/**
	static method to create the corrisponding Minimizer given the string
	Supported Minimizers types are:
	Minuit (TMinuit), Minuit2, GSLMultiMin, GSLMultiFit, GSLSimAn, Linear
	, Fumili, Genetic
	*/
	static ROOT::Math::Minimizer * CreateMinimizer(const std::string & minim
	izerType = "Minuit2", const std::string & algoType = "Migrad");

	/**
	static method to create the distribution sampler class given a string
	specifying the type
	Supported sampler types are:
	Unuran
	*/
	static ROOT::Math::DistSampler * CreateDistSampler(const std::string & s
	amplerType ="Unuran");

	};


	} // end namespace Fit	ClassDef(Factory,0) // The factory creates all MVA methods, and perf
		orms their training and testing
		};


	} // end namespace ROOT	} // namespace TMVA


	#endif /* ROOT_Fit_MinimizerFactory */	#endif

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

	FeldmanCousins.h	FeldmanCousins.h

	// @(#)root/roostats:$Id: FeldmanCousins.h 34109 2010-06-24 15:00:16Z monet a $	// @(#)root/roostats:$Id: FeldmanCousins.h 37403 2010-12-08 15:59:22Z monet a $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, 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 ROOSTATS_FeldmanCousins	#ifndef ROOSTATS_FeldmanCousins

	skipping to change at line 23	skipping to change at line 23

	#ifndef ROOT_Rtypes	#ifndef ROOT_Rtypes
	#include "Rtypes.h"	#include "Rtypes.h"
	#endif	#endif

	#ifndef ROOSTATS_IntervalCalculator	#ifndef ROOSTATS_IntervalCalculator
	#include "RooStats/IntervalCalculator.h"	#include "RooStats/IntervalCalculator.h"
	#endif	#endif

	#include "RooStats/ToyMCSampler.h"	#include "RooStats/ToyMCSampler.h"

	//#include "RooStats/ToyMCSampler2.h"
	#include "RooStats/ConfidenceBelt.h"	#include "RooStats/ConfidenceBelt.h"

		#include "RooStats/PointSetInterval.h"

	#include "RooAbsData.h"	#include "RooAbsData.h"
	#include "RooAbsPdf.h"	#include "RooAbsPdf.h"
	#include "RooArgSet.h"	#include "RooArgSet.h"
	#include "TList.h"	#include "TList.h"

	class RooAbsData;	class RooAbsData;

	namespace RooStats {	namespace RooStats {


	skipping to change at line 49	skipping to change at line 49
	public:	public:

	// FeldmanCousins();	// FeldmanCousins();

	// Common constructor	// Common constructor
	FeldmanCousins(RooAbsData& data, ModelConfig& model);	FeldmanCousins(RooAbsData& data, ModelConfig& model);

	virtual ~FeldmanCousins();	virtual ~FeldmanCousins();

	// Main interface to get a ConfInterval (will be a PointSetInterval)	// Main interface to get a ConfInterval (will be a PointSetInterval)

	virtual ConfInterval* GetInterval() const;	virtual PointSetInterval* GetInterval() const;

	// Get the size of the test (eg. rate of Type I error)	// Get the size of the test (eg. rate of Type I error)
	virtual Double_t Size() const {return fSize;}	virtual Double_t Size() const {return fSize;}
	// Get the Confidence level for the test	// Get the Confidence level for the test
	virtual Double_t ConfidenceLevel() const {return 1.-fSize;}	virtual Double_t ConfidenceLevel() const {return 1.-fSize;}
	// Set the DataSet	// Set the DataSet
	virtual void SetData(RooAbsData& /data/) {	virtual void SetData(RooAbsData& /data/) {
	cout << "DEPRECATED, set data in constructor" << endl;	cout << "DEPRECATED, set data in constructor" << endl;
	}	}
	// Set the Pdf	// Set the Pdf

	skipping to change at line 102	skipping to change at line 102
	void SetNBins(Int_t bins) {fNbins = bins;}	void SetNBins(Int_t bins) {fNbins = bins;}

	void FluctuateNumDataEntries(bool flag=true){fFluctuateData = flag;}	void FluctuateNumDataEntries(bool flag=true){fFluctuateData = flag;}

	void SaveBeltToFile(bool flag=true){	void SaveBeltToFile(bool flag=true){
	fSaveBeltToFile = flag;	fSaveBeltToFile = flag;
	if(flag) fCreateBelt = true;	if(flag) fCreateBelt = true;
	}	}
	void CreateConfBelt(bool flag=true){fCreateBelt = flag;}	void CreateConfBelt(bool flag=true){fCreateBelt = flag;}


		// Returns instance of TestStatSampler. Use to change properties of
		// TestStatSampler, e.g. GetTestStatSampler.SetTestSize(Double_t size
		);
		TestStatSampler* GetTestStatSampler() const;

	private:	private:

	// initializes fPointsToTest data member (mutable)	// initializes fPointsToTest data member (mutable)
	void CreateParameterPoints() const;	void CreateParameterPoints() const;

	// initializes fTestStatSampler data member (mutable)	// initializes fTestStatSampler data member (mutable)
	void CreateTestStatSampler() const;	void CreateTestStatSampler() const;

	Double_t fSize; // size of the test (eg. specified rate of Type I err or)	Double_t fSize; // size of the test (eg. specified rate of Type I err or)
	ModelConfig &fModel;	ModelConfig &fModel;

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

	Fitter.h	Fitter.h

	// @(#)root/mathcore:$Id: Fitter.h 34809 2010-08-13 12:48:34Z moneta $	// @(#)root/mathcore:$Id: Fitter.h 36764 2010-11-19 10:02:00Z moneta $
	// Author: L. Moneta Wed Aug 30 11:05:19 2006	// Author: L. Moneta Wed Aug 30 11:05:19 2006

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for class Fitter	// Header file for class Fitter

	skipping to change at line 152	skipping to change at line 152
	*/	*/
	template < class Data , class Function>	template < class Data , class Function>
	bool LikelihoodFit( const Data & data, const Function & func) {	bool LikelihoodFit( const Data & data, const Function & func) {
	SetFunction(func);	SetFunction(func);
	return DoLikelihoodFit(data);	return DoLikelihoodFit(data);
	}	}

	/**	/**
	Fit using the a generic FCN function as a C++ callable object impleme nting	Fit using the a generic FCN function as a C++ callable object impleme nting
	double () (const double *)	double () (const double *)

	The function dimension (i.e. the number of parameter) is needed in th	Note that the function dimension (i.e. the number of parameter) is ne
	is case	eded in this case
	For the other arguments same consideration as in the previous methods	For the options see documentation for following methods FitFCN(IMulti
		GenFunction & fcn,..)
	*/	*/
	template <class Function>	template <class Function>

	bool FitFCN(unsigned int npar, Function & fcn, const double * params = 0, unsigned int dataSize = 0);	bool FitFCN(unsigned int npar, Function & fcn, const double * params = 0, unsigned int dataSize = 0, bool chi2fit = false);

	/**	/**

	fit using the given FCN function represented by a multi-dimensional f unction interface	Fit using the given FCN function represented by a multi-dimensional f unction interface
	(ROOT::Math::IMultiGenFunction).	(ROOT::Math::IMultiGenFunction).

	Give optionally initial the parameter values and data size to have th	Give optionally the initial arameter values, data size to have the fi
	e fit Ndf correctly	t Ndf correctly
	set in the FitResult.	set in the FitResult and flag specifying if it is a chi2 fit.
	If the parameters values are not given (parameter pointers=0) the	Note that if the parameters values are not given (params=0) the
	current parameter settings are used. The parameter settings can be cr eated before	current parameter settings are used. The parameter settings can be cr eated before
	by using the FitConfig::SetParamsSetting. If they have not been creat ed they are created	by using the FitConfig::SetParamsSetting. If they have not been creat ed they are created

	automatically when the params pointer is not zero	automatically when the params pointer is not zero.
		Note that passing a params != 0 will set the parameter settings to th
		e new value AND also the
		step sizes to some pre-defined value (stepsize = 0.3 * abs(parameter_
		value) )
	*/	*/

	bool FitFCN(const ROOT::Math::IMultiGenFunction & fcn, const double * pa rams = 0, unsigned int dataSize = 0 );	bool FitFCN(const ROOT::Math::IMultiGenFunction & fcn, const double * pa rams = 0, unsigned int dataSize = 0, bool chi2fit = false);

	/**	/**
	Fit using the given FCN function representing a multi-dimensional gra dient function	Fit using the given FCN function representing a multi-dimensional gra dient function
	interface (ROOT::Math::IMultiGradFunction). In this case the minimize r will use the	interface (ROOT::Math::IMultiGradFunction). In this case the minimize r will use the
	gradient information provided by the function.	gradient information provided by the function.

	For the other arguments same consideration as in the previous method	For the options same consideration as in the previous method
	*/	*/

	bool FitFCN(const ROOT::Math::IMultiGradFunction & fcn, const double * p arams = 0, unsigned int dataSize = 0);	bool FitFCN(const ROOT::Math::IMultiGradFunction & fcn, const double * p arams = 0, unsigned int dataSize = 0, bool chi2fit = false);

	/**	/**
	fit using user provided FCN with Minuit-like interface	fit using user provided FCN with Minuit-like interface

	Parameter Settings must have be created before	If npar = 0 it is assumed that the parameters are specified in the pa
		rameter settings created before
		For the options same consideration as in the previous method
	*/	*/
	typedef void (* MinuitFCN_t )(int &npar, double gin, double &f, double u, int flag);	typedef void (* MinuitFCN_t )(int &npar, double gin, double &f, double u, int flag);

	bool FitFCN( MinuitFCN_t fcn);	bool FitFCN( MinuitFCN_t fcn, int npar = 0, const double * params = 0, u nsigned int dataSize = 0, bool chi2fit = false);

	/**	/**
	do a linear fit on a set of bin-data	do a linear fit on a set of bin-data
	*/	*/
	bool LinearFit(const BinData & data) { return DoLinearFit(data); }	bool LinearFit(const BinData & data) { return DoLinearFit(data); }

	/**	/**
	Set the fitted function (model function) from a parametric function interface	Set the fitted function (model function) from a parametric function interface
	*/	*/
	void SetFunction(const IModelFunction & func);	void SetFunction(const IModelFunction & func);

	skipping to change at line 320	skipping to change at line 323

	// implementation of inline methods	// implementation of inline methods

	#ifndef __CINT__	#ifndef __CINT__

	#ifndef ROOT_Math_WrappedFunction	#ifndef ROOT_Math_WrappedFunction
	#include "Math/WrappedFunction.h"	#include "Math/WrappedFunction.h"
	#endif	#endif

	template<class Function>	template<class Function>

	bool ROOT::Fit::Fitter::FitFCN(unsigned int npar, Function & f, const doubl e * par, unsigned int datasize) {	bool ROOT::Fit::Fitter::FitFCN(unsigned int npar, Function & f, const doubl e * par, unsigned int datasize,bool chi2fit) {
	ROOT::Math::WrappedMultiFunction<Function &> wf(f,npar);	ROOT::Math::WrappedMultiFunction<Function &> wf(f,npar);

	return FitFCN(wf,par,datasize);	return FitFCN(wf,par,datasize,chi2fit);
	}	}

	#endif // endif __CINT__	#endif // endif __CINT__

	#endif /* ROOT_Fit_Fitter */	#endif /* ROOT_Fit_Fitter */

End of changes. 13 change blocks.
	18 lines changed or deleted	25 lines changed or added

	FumiliFCNAdapter.h	FumiliFCNAdapter.h

	// @(#)root/minuit2:$Id: FumiliFCNAdapter.h 26014 2008-10-29 16:37:28Z mone ta $	// @(#)root/minuit2:$Id: FumiliFCNAdapter.h 37067 2010-11-29 14:38:08Z mone ta $
	// Author: L. Moneta 10/2006	// Author: L. Moneta 10/2006

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 ROOT Foundation, CERN/PH-SFT *	* Copyright (c) 2006 ROOT Foundation, CERN/PH-SFT *
	* *	* *
	**********************************************************************/	**********************************************************************/

	#ifndef ROOT_Minuit2_FumiliFCNAdapter	#ifndef ROOT_Minuit2_FumiliFCNAdapter
	#define ROOT_Minuit2_FumiliFCNAdapter	#define ROOT_Minuit2_FumiliFCNAdapter

	skipping to change at line 154	skipping to change at line 154
	double gfj = gf[j] ;	double gfj = gf[j] ;
	grad[j] -= gfj;	grad[j] -= gfj;
	for (unsigned int k = j; k < npar; ++ k) {	for (unsigned int k = j; k < npar; ++ k) {
	int idx = j + k*(k+1)/2;	int idx = j + k*(k+1)/2;
	hess[idx] += gfj * gf[k] ;	hess[idx] += gfj * gf[k] ;
	}	}
	}	}
	}	}
	}	}
	else {	else {

	MN_ERROR_MSG("FumiliFCNAdapter: fit method is not supported");	MN_ERROR_MSG("FumiliFCNAdapter: type of fit method is not supported, it must be chi2 or log-likelihood");
	}	}
	}	}

	} // end namespace Minuit2	} // end namespace Minuit2

	} // end namespace ROOT	} // end namespace ROOT

	#endif //ROOT_Minuit2_FCNAdapter	#endif //ROOT_Minuit2_FCNAdapter

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

	GSLIntegrator.h	GSLIntegrator.h

	// @(#)root/mathmore:$Id: GSLIntegrator.h 33180 2010-04-25 10:14:07Z moneta $	// @(#)root/mathmore:$Id: GSLIntegrator.h 36764 2010-11-19 10:02:00Z moneta $
	// Authors: L. Moneta, A. Zsenei 08/2005	// Authors: L. Moneta, A. Zsenei 08/2005

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *
	* *	* *
	* This library is free software; you can redistribute it and/or *	* This library is free software; you can redistribute it and/or *
	* modify it under the terms of the GNU General Public License *	* modify it under the terms of the GNU General Public License *
	* as published by the Free Software Foundation; either version 2 *	* as published by the Free Software Foundation; either version 2 *
	* of the License, or (at your option) any later version. *	* of the License, or (at your option) any later version. *

	skipping to change at line 321	skipping to change at line 321
	/**	/**
	return the estimate of the absolute Error of the last Integral cal culation	return the estimate of the absolute Error of the last Integral cal culation
	*/	*/
	double Error() const;	double Error() const;

	/**	/**
	return the Error Status of the last Integral calculation	return the Error Status of the last Integral calculation
	*/	*/
	int Status() const;	int Status() const;


		/**
		return number of function evaluations in calculating the integral
		*/
		int NEval() const { return fNEval; }

	// setter for control Parameters (getters are not needed so far )	// setter for control Parameters (getters are not needed so far )

	/**	/**
	set the desired relative Error	set the desired relative Error
	*/	*/
	void SetRelTolerance(double relTolerance);	void SetRelTolerance(double relTolerance);

	/**	/**
	set the desired absolute Error	set the desired absolute Error
	*/	*/
	void SetAbsTolerance(double absTolerance);	void SetAbsTolerance(double absTolerance);

	/**	/**
	set the integration rule (Gauss-Kronrod rule).	set the integration rule (Gauss-Kronrod rule).
	The possible rules are defined in the Integration::GKRule enumeratio n.	The possible rules are defined in the Integration::GKRule enumeratio n.
	The integration rule can be modified only for ADAPTIVE type integrat ions	The integration rule can be modified only for ADAPTIVE type integrat ions
	*/	*/
	void SetIntegrationRule(Integration::GKRule );	void SetIntegrationRule(Integration::GKRule );


		/// set the options
		virtual void SetOptions(const ROOT::Math::IntegratorOneDimOptions & o
		pt);

		/// get the option used for the integration
		virtual ROOT::Math::IntegratorOneDimOptions Options() const;

		/// get type name
		IntegrationOneDim::Type GetType() const { return fType; }

		/**
		return the name
		*/
		const char * GetTypeName() const;

	protected:	protected:

	// internal method to check validity of GSL function pointer	// internal method to check validity of GSL function pointer
	bool CheckFunction();	bool CheckFunction();

	private:	private:

	Integration::Type fType;	Integration::Type fType;
	Integration::GKRule fRule;	Integration::GKRule fRule;
	double fAbsTol;	double fAbsTol;
	double fRelTol;	double fRelTol;
	size_t fSize;	size_t fSize;
	size_t fMaxIntervals;	size_t fMaxIntervals;

	// cache Error, Result and Status of integration	// cache Error, Result and Status of integration

	double fResult;	double fResult;
	double fError;	double fError;
	int fStatus;	int fStatus;

		int fNEval;

	// GSLIntegrationAlgorithm * fAlgorithm;	// GSLIntegrationAlgorithm * fAlgorithm;

	GSLFunctionWrapper * fFunction;	GSLFunctionWrapper * fFunction;
	GSLIntegrationWorkspace * fWorkspace;	GSLIntegrationWorkspace * fWorkspace;

	};	};

	} // namespace Math	} // namespace Math
	} // namespace ROOT	} // namespace ROOT

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

	GSLMCIntegrator.h	GSLMCIntegrator.h

	// @(#)root/mathmore:$Id: GSLMCIntegrator.h 26307 2008-11-20 09:51:19Z mone ta $	// @(#)root/mathmore:$Id: GSLMCIntegrator.h 36806 2010-11-20 11:09:14Z mone ta $
	// Author: Magdalena Slawinska 08/2007	// Author: Magdalena Slawinska 08/2007

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2007 ROOT Foundation, CERN/PH-SFT *	* Copyright (c) 2007 ROOT Foundation, CERN/PH-SFT *
	* *	* *
	* This library is free software; you can redistribute it and/or *	* This library is free software; you can redistribute it and/or *
	* modify it under the terms of the GNU General Public License *	* modify it under the terms of the GNU General Public License *
	* as published by the Free Software Foundation; either version 2 *	* as published by the Free Software Foundation; either version 2 *
	* of the License, or (at your option) any later version. *	* of the License, or (at your option) any later version. *

	skipping to change at line 94	skipping to change at line 94
	instantiate using the plugin manager (plugin name is "GSLMCIntegrator")	instantiate using the plugin manager (plugin name is "GSLMCIntegrator")

	@ingroup MCIntegration	@ingroup MCIntegration

	*/	*/

	class GSLMCIntegrator : public VirtualIntegratorMultiDim {	class GSLMCIntegrator : public VirtualIntegratorMultiDim {

	public:	public:


		typedef MCIntegration::Type Type;

	// constructors	// constructors


	/** constructor of GSL MCIntegrator. VEGAS MC is set as default integ	// /**
	ration type	// constructor of GSL MCIntegrator using all the default options
		// */
		// GSLMCIntegrator( );


	@param type type of integration. The possible types are defined in th	/** constructor of GSL MCIntegrator. VEGAS MC is set as default inte
	e Integration::Type enumeration	gration type

		@param type type of integration. The possible types are defined in th
		e MCIntegration::Type enumeration
		Default is VEGAS
	@param absTol desired absolute Error	@param absTol desired absolute Error
	@param relTol desired relative Error	@param relTol desired relative Error
	@param calls maximum number of function calls	@param calls maximum number of function calls

	*/


		NOTE: When the default values are used , the options are taken from t
		eh static method of ROOT::Math::IntegratorMultiDimOptions
		*/
	explicit	explicit

	GSLMCIntegrator(MCIntegration::Type type = MCIntegration::kVEGAS, dou ble absTol = 1.E-6, double relTol = 1E-4, unsigned int calls = 500000);	GSLMCIntegrator(MCIntegration::Type type = MCIntegration::kVEGAS, dou ble absTol = 0, double relTol = 0, unsigned int calls = 0 );

	/** constructor of GSL MCIntegrator. VEGAS MC is set as default integ ration type	/** constructor of GSL MCIntegrator. VEGAS MC is set as default integ ration type

	@param type type of integration using a char * (required by plug-in m anager)	@param type type of integration using a char * (required by plug-in m anager)
	@param absTol desired absolute Error	@param absTol desired absolute Error
	@param relTol desired relative Error	@param relTol desired relative Error
	@param calls maximum number of function calls	@param calls maximum number of function calls
	*/	*/


	explicit
	GSLMCIntegrator(const char * type, double absTol, double relTol, uns igned int calls);	GSLMCIntegrator(const char * type, double absTol, double relTol, uns igned int calls);

	/**	/**
	destructor	destructor
	*/	*/
	virtual ~GSLMCIntegrator();	virtual ~GSLMCIntegrator();

	// disable copy ctrs	// disable copy ctrs

	private:	private:

	skipping to change at line 189	skipping to change at line 196
	/**	/**
	return the estimate of the absolute Error of the last Integral cal culation	return the estimate of the absolute Error of the last Integral cal culation
	*/	*/
	double Error() const;	double Error() const;

	/**	/**
	return the Error Status of the last Integral calculation	return the Error Status of the last Integral calculation
	*/	*/
	int Status() const;	int Status() const;


		/**
		return number of function evaluations in calculating the integral
		(This is an fixed by the user)
		*/
		int NEval() const { return fCalls; }

	// setter for control Parameters (getters are not needed so far )	// setter for control Parameters (getters are not needed so far )

	/**	/**
	set the desired relative Error	set the desired relative Error
	*/	*/
	void SetRelTolerance(double relTolerance);	void SetRelTolerance(double relTolerance);

	/**	/**
	set the desired absolute Error	set the desired absolute Error
	*/	*/
	void SetAbsTolerance(double absTolerance);	void SetAbsTolerance(double absTolerance);

	/**	/**

	to be added later as options for basic MC methods	set the integration options
	The possible rules are defined in the Integration::GKRule enumeratio
	n.
	The integration rule can be modified only for ADAPTIVE type integrat
	ions
	*/	*/

	//void SetIntegrationRule(Integration::GKRule );	void SetOptions(const ROOT::Math::IntegratorMultiDimOptions & opt);

	/**	/**
	set random number generator	set random number generator
	*/	*/
	void SetGenerator(GSLRngWrapper* r);	void SetGenerator(GSLRngWrapper* r);

	/**	/**
	set integration method	set integration method
	*/	*/
	void SetType(MCIntegration::Type type);	void SetType(MCIntegration::Type type);

	/**	/**

		set integration method using a name instead of an enumeration
		*/
		void SetTypeName(const char * typeName);

		/**
	set integration mode for VEGAS method	set integration mode for VEGAS method
	The possible MODE are :	The possible MODE are :
	MCIntegration::kIMPORTANCE (default) : VEGAS will use importance s ampling	MCIntegration::kIMPORTANCE (default) : VEGAS will use importance s ampling
	MCIntegration::kSTRATIFIED : VEGAS will use stratified s ampling if certain condition are satisfied	MCIntegration::kSTRATIFIED : VEGAS will use stratified s ampling if certain condition are satisfied
	MCIntegration::kIMPORTANCE_ONLY : VEGAS will always use impor tance smapling	MCIntegration::kIMPORTANCE_ONLY : VEGAS will always use impor tance smapling
	*/	*/

	void SetMode(MCIntegration::Mode mode);	void SetMode(MCIntegration::Mode mode);

	/**	/**

	skipping to change at line 253	skipping to change at line 269
	/**	/**
	returns the error sigma from the last iteration of the Vegas algori thm	returns the error sigma from the last iteration of the Vegas algori thm
	*/	*/
	double Sigma();	double Sigma();

	/**	/**
	returns chi-squared per degree of freedom for the estimate of the i ntegral in the Vegas algorithm	returns chi-squared per degree of freedom for the estimate of the i ntegral in the Vegas algorithm
	*/	*/
	double ChiSqr();	double ChiSqr();


		/**
		return the type
		(need to be called GetType to avois a conflict with typedef)
		*/
		MCIntegration::Type GetType() const { return fType; }

		/**
		return the name
		*/
		const char * GetTypeName() const;

		/**
		get the option used for the integration
		*/
		ROOT::Math::IntegratorMultiDimOptions Options() const;

		/**
		get the specific options (for Vegas or Miser)
		in term of string- name
		*/
		ROOT::Math::IOptions * ExtraOptions() const;

	protected:	protected:

	// internal method to check validity of GSL function pointer	// internal method to check validity of GSL function pointer
	bool CheckFunction();	bool CheckFunction();

	// set internally the type of integration method	// set internally the type of integration method
	void DoInitialize( );	void DoInitialize( );

	private:	private:
	//type of intergation method	//type of intergation method
	MCIntegration::Type fType;	MCIntegration::Type fType;


	//mode for VEGAS integration
	MCIntegration::Mode fMode;
	GSLRngWrapper * fRng;	GSLRngWrapper * fRng;


	double fAbsTol;
	double fRelTol;
	unsigned int fDim;	unsigned int fDim;
	unsigned int fCalls;	unsigned int fCalls;

		double fAbsTol;
		double fRelTol;

	// cache Error, Result and Status of integration	// cache Error, Result and Status of integration

	double fResult;	double fResult;
	double fError;	double fError;
	int fStatus;	int fStatus;

	GSLMCIntegrationWorkspace * fWorkspace;	GSLMCIntegrationWorkspace * fWorkspace;
	GSLMonteFunctionWrapper * fFunction;	GSLMonteFunctionWrapper * fFunction;


End of changes. 16 change blocks.
	19 lines changed or deleted	54 lines changed or added

	GSLRndmEngines.h	GSLRndmEngines.h

	// @(#)root/mathmore:$Id: GSLRndmEngines.h 33304 2010-04-30 08:39:37Z monet a $	// @(#)root/mathmore:$Id: GSLRndmEngines.h 37441 2010-12-09 16:27:54Z monet a $
	// Author: L. Moneta, A. Zsenei 08/2005	// Author: L. Moneta, A. Zsenei 08/2005

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *
	* *	* *
	* This library is free software; you can redistribute it and/or *	* This library is free software; you can redistribute it and/or *
	* modify it under the terms of the GNU General Public License *	* modify it under the terms of the GNU General Public License *
	* as published by the Free Software Foundation; either version 2 *	* as published by the Free Software Foundation; either version 2 *
	* of the License, or (at your option) any later version. *	* of the License, or (at your option) any later version. *

	skipping to change at line 229	skipping to change at line 229
	Poisson distribution	Poisson distribution
	*/	*/
	unsigned int Poisson(double mu) const;	unsigned int Poisson(double mu) const;

	/**	/**
	Binomial distribution	Binomial distribution
	*/	*/
	unsigned int Binomial(double p, unsigned int n) const;	unsigned int Binomial(double p, unsigned int n) const;

	/**	/**

		Negative Binomial distribution
		*/
		unsigned int NegativeBinomial(double p, double n) const;

		/**
	Multinomial distribution	Multinomial distribution
	*/	*/
	std::vector<unsigned int> Multinomial( unsigned int ntot, const std:: vector<double> & p ) const;	std::vector<unsigned int> Multinomial( unsigned int ntot, const std:: vector<double> & p ) const;

	//@}	//@}

	protected:	protected:

	/// internal method used by the derived class to set the type of gene rators	/// internal method used by the derived class to set the type of gene rators
	void SetType(GSLRngWrapper * r) {	void SetType(GSLRngWrapper * r) {

	skipping to change at line 264	skipping to change at line 269

	@ingroup Random	@ingroup Random
	*/	*/
	class GSLRngMT : public GSLRandomEngine {	class GSLRngMT : public GSLRandomEngine {
	public:	public:
	GSLRngMT();	GSLRngMT();
	};	};

	//______________________________________________________________________ _______________	//______________________________________________________________________ _______________
	/**	/**

	Ranlux generator (James, Luscher) (defaul luxury)	Old Ranlux generator (James, Luscher) (default luxury level, p = 223)
		(This is eequivalent to TRandom1 with default luxury level)
	see <A HREF="http://www.gnu.org/software/gsl/manual/html_node/Random- number-generator-algorithms.html">here</A>	see <A HREF="http://www.gnu.org/software/gsl/manual/html_node/Random- number-generator-algorithms.html">here</A>

	@ingroup Random	@ingroup Random
	*/	*/
	class GSLRngRanLux : public GSLRandomEngine {	class GSLRngRanLux : public GSLRandomEngine {
	public:	public:
	GSLRngRanLux();	GSLRngRanLux();
	};	};

	//______________________________________________________________________ _______________	//______________________________________________________________________ _______________
	/**	/**

	Second generation of Ranlux generator (with luxury level of 2)	Second generation of Ranlux generator for single precision with luxu
		ry level of 1
		(It throws away 202 values for every 12 used)
		see <A HREF="http://www.gnu.org/software/gsl/manual/html_node/Random-
		number-generator-algorithms.html">here</A>

		@ingroup Random
		*/
		class GSLRngRanLuxS1 : public GSLRandomEngine {
		public:
		GSLRngRanLuxS1();
		};
		typedef GSLRngRanLuxS1 GSLRngRanLux1; // for backward compatibility

		//______________________________________________________________________
		_______________
		/**
		Second generation of Ranlux generator for Single precision with luxu
		ry level of 2
		(It throws away 397 value for every 12 used)
		see <A HREF="http://www.gnu.org/software/gsl/manual/html_node/Random-
		number-generator-algorithms.html">here</A>

		@ingroup Random
		*/
		class GSLRngRanLuxS2 : public GSLRandomEngine {
		public:
		GSLRngRanLuxS2();
		};
		typedef GSLRngRanLuxS2 GSLRngRanLux2; // for backward compatibility

		//______________________________________________________________________
		_______________
		/**
		Double precision (48 bits) version of Second generation of Ranlux gen
		erator with luxury level of 1
		(It throws away 202 value for every 12 used)
	see <A HREF="http://www.gnu.org/software/gsl/manual/html_node/Random- number-generator-algorithms.html">here</A>	see <A HREF="http://www.gnu.org/software/gsl/manual/html_node/Random- number-generator-algorithms.html">here</A>

	@ingroup Random	@ingroup Random
	*/	*/

	class GSLRngRanLux2 : public GSLRandomEngine {	class GSLRngRanLuxD1 : public GSLRandomEngine {
	public:	public:

	GSLRngRanLux2();	GSLRngRanLuxD1();
	};	};

	//______________________________________________________________________ _______________	//______________________________________________________________________ _______________
	/**	/**

	48 bits version of Second generation of Ranlux generator (with luxur	Double precision (48 bits) version of Second generation of Ranlux gen
	y level of 2)	erator with luxury level of 2
		(It throws away 397 value for every 12 used)
	see <A HREF="http://www.gnu.org/software/gsl/manual/html_node/Random- number-generator-algorithms.html">here</A>	see <A HREF="http://www.gnu.org/software/gsl/manual/html_node/Random- number-generator-algorithms.html">here</A>

	@ingroup Random	@ingroup Random
	*/	*/

	class GSLRngRanLux48 : public GSLRandomEngine {	class GSLRngRanLuxD2 : public GSLRandomEngine {
	public:	public:

	GSLRngRanLux48();	GSLRngRanLuxD2();
	};	};

		typedef GSLRngRanLuxD2 GSLRngRanLux48; // for backward compatibility

	//______________________________________________________________________ _______________	//______________________________________________________________________ _______________
	/**	/**
	Tausworthe generator by L'Ecuyer	Tausworthe generator by L'Ecuyer
	see <A HREF="http://www.gnu.org/software/gsl/manual/html_node/Random- number-generator-algorithms.html">here</A>	see <A HREF="http://www.gnu.org/software/gsl/manual/html_node/Random- number-generator-algorithms.html">here</A>

	@ingroup Random	@ingroup Random
	*/	*/
	class GSLRngTaus : public GSLRandomEngine {	class GSLRngTaus : public GSLRandomEngine {
	public:	public:

End of changes. 10 change blocks.
	9 lines changed or deleted	53 lines changed or added

	G__ci.h	G__ci.h

	skipping to change at line 811	skipping to change at line 811
	#define G__TIMEOUT 10 /* Timeout after segv,buserror,etc */	#define G__TIMEOUT 10 /* Timeout after segv,buserror,etc */

	/**************************************************************************	/**************************************************************************
	* variable identity	* variable identity
	**************************************************************************/	**************************************************************************/
	#define G__AUTO (-1)	#define G__AUTO (-1)
	#define G__LOCALSTATIC (-2)	#define G__LOCALSTATIC (-2)
	#define G__LOCALSTATICBODY (-3)	#define G__LOCALSTATICBODY (-3)
	#define G__COMPILEDGLOBAL (-4)	#define G__COMPILEDGLOBAL (-4)
	#define G__AUTOARYDISCRETEOBJ (-5)	#define G__AUTOARYDISCRETEOBJ (-5)

		#define G__USING_VARIABLE (-6)
		#define G__USING_STATIC_VARIABLE (-7)

	#define G__LOCAL 0	#define G__LOCAL 0
	#ifdef G__MEMBERFUNC	#ifdef G__MEMBERFUNC
	#define G__MEMBER 2	#define G__MEMBER 2
	#define G__GLOBAL 4	#define G__GLOBAL 4
	#define G__NOTHING 6	#define G__NOTHING 6
	#else	#else
	#define G__GLOBAL 2	#define G__GLOBAL 2
	#endif	#endif


	skipping to change at line 1155	skipping to change at line 1157
	#define G__BYTECODE_FAILURE 2	#define G__BYTECODE_FAILURE 2
	#define G__BYTECODE_SUCCESS 3	#define G__BYTECODE_SUCCESS 3
	#define G__BYTECODE_ANALYSIS 4 /* ON1164 */	#define G__BYTECODE_ANALYSIS 4 /* ON1164 */

	/**************************************************************************	/**************************************************************************
	* structure for function and array parameter	* structure for function and array parameter
	*	*
	**************************************************************************/	**************************************************************************/
	struct G__param {	struct G__param {
	int paran;	int paran;

	#ifdef G__OLDIMPLEMENTATION1530
	char parameter[G__MAXFUNCPARA][G__ONELINE];
	#endif
	G__value para[G__MAXFUNCPARA];	G__value para[G__MAXFUNCPARA];

	#ifndef G__OLDIMPLEMENTATION1530
	char parameter[G__MAXFUNCPARA][G__ONELINE];	char parameter[G__MAXFUNCPARA][G__ONELINE];

	#endif
	};	};

	#if defined(__cplusplus) && !defined(__CINT__)	#if defined(__cplusplus) && !defined(__CINT__)
	} /* extern C 1 */	} /* extern C 1 */
	#endif	#endif

	/**************************************************************************	/**************************************************************************
	* Interface Method type	* Interface Method type
	*	*
	**************************************************************************/	**************************************************************************/

	skipping to change at line 1367	skipping to change at line 1364
	/**************************************************************************	/**************************************************************************
	* Exported Functions	* Exported Functions
	*	*
	**************************************************************************/	**************************************************************************/
	#ifdef G__ANSI	#ifdef G__ANSI
	#define G__P(funcparam) funcparam	#define G__P(funcparam) funcparam
	#else	#else
	#define G__P(funcparam) ()	#define G__P(funcparam) ()
	#endif	#endif


	extern G__EXPORT unsigned long G__uint G__P((G__value buf));

	#if defined(G__DEBUG) && !defined(G__MEMTEST_C)	#if defined(G__DEBUG) && !defined(G__MEMTEST_C)
	#include "src/memtest.h"	#include "src/memtest.h"
	#endif	#endif

	#ifndef G__WILDCARD	#ifndef G__WILDCARD
	#define G__WILDCARD	#define G__WILDCARD
	#endif	#endif

	/**************************************************************************	/**************************************************************************
	* Variable argument, byte layout policy	* Variable argument, byte layout policy
	************************************************************************** /	************************************************************************** /
	#define G__VAARG_SIZE 1024	#define G__VAARG_SIZE 1024

	typedef struct {	typedef struct {
	union {	union {
	char d[G__VAARG_SIZE];	char d[G__VAARG_SIZE];
	long i[G__VAARG_SIZE/sizeof(long)];	long i[G__VAARG_SIZE/sizeof(long)];
	} x;	} x;
	} G__va_arg_buf;	} G__va_arg_buf;


		// cross-compiling for iOS and iOS simulator (assumes host is Intel Mac OS
		X)
		#if defined(R__IOSSIM) \|\| defined(R__IOS)
		#ifdef __x86_64__
		#define R__x86_64 1
		#undef __x86_64__
		#endif
		#ifdef __i386__
		#define R__i386 1
		#undef __i386__
		#endif
		#ifdef R__IOSSIM
		#define __i386__ 1
		#endif
		#ifdef R__IOS
		#define __arm__ 1
		#endif
		#endif

	#if (defined(__i386__) && (defined(__linux) \|\| defined(__APPLE__))) \|\| \	#if (defined(__i386__) && (defined(__linux) \|\| defined(__APPLE__))) \|\| \
	defined(_WIN32) \|\| defined(G__CYGWIN)	defined(_WIN32) \|\| defined(G__CYGWIN)
	/**********************************************	/**********************************************
	* Intel architecture, aligns in multiple of 4	* Intel architecture, aligns in multiple of 4
	* \|1111\|22 \|3 \|44444444\|55555555555555 \|	* \|1111\|22 \|3 \|44444444\|55555555555555 \|
	**********************************************/	**********************************************/
	#define G__VAARG_INC_COPY_N 4	#define G__VAARG_INC_COPY_N 4

	#elif (defined(__linux)&&defined(__ia64__))	#elif (defined(__linux)&&defined(__ia64__))
	/**********************************************	/**********************************************

	skipping to change at line 1508	skipping to change at line 1521
	/**********************************************	/**********************************************
	* Other platforms,	* Other platforms,
	* Try copying object as value.	* Try copying object as value.
	**********************************************/	**********************************************/
	#define G__VAARG_NOSUPPORT	#define G__VAARG_NOSUPPORT
	#define G__VAARG_INC_COPY_N 4	#define G__VAARG_INC_COPY_N 4
	/* #define G__VAARG_PASS_BY_REFERENCE 8 */	/* #define G__VAARG_PASS_BY_REFERENCE 8 */

	#endif	#endif


		// cross-compiling for iOS and iOS simulator (assumes host is Intel Mac OS
		X)
		#if defined(R__IOSSIM) \|\| defined(R__IOS)
		#undef __i386__
		#undef __arm__
		#ifdef R__x86_64
		#define __x86_64__ 1
		#endif
		#ifdef R__i386
		#define __i386__ 1
		#endif
		#endif

	struct G__va_list_para {	struct G__va_list_para {
	struct G__param *libp;	struct G__param *libp;
	int i;	int i;
	};	};

	extern G__EXPORT G__value (G__GetSpecialObject) (G__CONST char name,void ptr,void ppdict);	extern G__EXPORT G__value (G__GetSpecialObject) (G__CONST char name,void ptr,void ppdict);
	extern G__EXPORT int (G__ScriptCompiler)(G__CONST char,G__CONST char*);	extern G__EXPORT int (G__ScriptCompiler)(G__CONST char,G__CONST char*);

	typedef int (G__IgnoreInclude) G__P((const char fname,const char* expande dfname));	typedef int (G__IgnoreInclude) G__P((const char fname,const char* expande dfname));
	typedef void G__parse_hook_t ();	typedef void G__parse_hook_t ();

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

	GaussLegendreIntegrator.h	GaussLegendreIntegrator.h

	// @(#)root/mathcore:$Id: GaussLegendreIntegrator.h 35385 2010-09-17 15:32: 11Z moneta $	// @(#)root/mathcore:$Id: GaussLegendreIntegrator.h 36764 2010-11-19 10:02: 00Z moneta $
	// Authors: David Gonzalez Maline 01/2008	// Authors: David Gonzalez Maline 01/2008

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 , LCG ROOT MathLib Team *	* Copyright (c) 2006 , LCG ROOT MathLib Team *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for GaussIntegrator	// Header file for GaussIntegrator

	skipping to change at line 65	skipping to change at line 65

	/** This method is not implemented. */	/** This method is not implemented. */
	virtual void SetAbsTolerance (double);	virtual void SetAbsTolerance (double);

	/** Returns the arrays x and w containing the abscissa and weight of	/** Returns the arrays x and w containing the abscissa and weight of
	the Gauss-Legendre n-point quadrature formula.	the Gauss-Legendre n-point quadrature formula.

	Gauss-Legendre: W(x)=1 -1<x<1	Gauss-Legendre: W(x)=1 -1<x<1
	(j+1)P_{j+1} = (2j+1)xP_j-jP_{j-1}	(j+1)P_{j+1} = (2j+1)xP_j-jP_{j-1}
	*/	*/

	void GetWeightVectors(double x, double w);	void GetWeightVectors(double x, double w) const;

		int GetNumberPoints() const { return fNum; }

		/**
		return number of function evaluations in calculating the integral
		This is equivalent to the number of points
		*/
		int NEval() const { return fNum; }

		/// get the option used for the integration
		virtual ROOT::Math::IntegratorOneDimOptions Options() const;

		// set the options
		virtual void SetOptions(const ROOT::Math::IntegratorOneDimOptions & opt)
		;

	private:	private:

	/**	/**
	Integration surrugate method. Return integral of passed function in interval [a,b]	Integration surrugate method. Return integral of passed function in interval [a,b]
	Reimplement method of GaussIntegrator using CalcGaussLegendreSampling Points	Reimplement method of GaussIntegrator using CalcGaussLegendreSampling Points
	*/	*/
	virtual double DoIntegral (double a, double b, const IGenFunction* func) ;	virtual double DoIntegral (double a, double b, const IGenFunction* func) ;

	/**	/**

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

	GoFTest.h	GoFTest.h

	// @(#)root/mathcore:$Id: GoFTest.h 35808 2010-09-27 18:40:50Z moneta $	// @(#)root/mathcore:$Id: GoFTest.h 36911 2010-11-24 17:08:43Z moneta $
	// Authors: Bartolomeu Rabacal 05/2010	// Authors: Bartolomeu Rabacal 05/2010
	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 , LCG ROOT MathLib Team *	* Copyright (c) 2006 , LCG ROOT MathLib Team *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/
	// Header file for GoFTest	// Header file for GoFTest

	#include <memory>	#include <memory>

	skipping to change at line 46	skipping to change at line 46
	kGaussian,	kGaussian,
	kLogNormal,	kLogNormal,
	kExponential	kExponential
	};	};

	enum EUserDistribution { // User input distribution option	enum EUserDistribution { // User input distribution option
	kCDF,	kCDF,
	kPDF // Default value	kPDF // Default value
	};	};


	enum ETestType { // Goodness of Fit test types for using with the class' s unary funtion as a shorthand for the in-built methods	enum ETestType { // Goodness of Fit test types for using with the class' s unary funtions as a shorthand for the in-built methods
	kAD, // Anderson-Darling Test. Default value	kAD, // Anderson-Darling Test. Default value
	kAD2s, // Anderson-Darling 2-Samples Test	kAD2s, // Anderson-Darling 2-Samples Test
	kKS, // Kolmogorov-Smirnov Test	kKS, // Kolmogorov-Smirnov Test
	kKS2s // Kolmogorov-Smirnov 2-Samples Test	kKS2s // Kolmogorov-Smirnov 2-Samples Test
	};	};

	/* Constructor for using only with 2-samples tests */	/* Constructor for using only with 2-samples tests */

	GoFTest( UInt_t sample1Size, const Double_t* sample1, UInt_t sample2Size , const Double_t* sample2 );	GoFTest(UInt_t sample1Size, const Double_t* sample1, UInt_t sample2Size, const Double_t* sample2);

	/* Constructor for using only with 1-sample tests with a specified distr ibution */	/* Constructor for using only with 1-sample tests with a specified distr ibution */
	GoFTest(UInt_t sampleSize, const Double_t* sample, EDistribution dist = kUndefined);	GoFTest(UInt_t sampleSize, const Double_t* sample, EDistribution dist = kUndefined);

	/* Templated constructor for using only with 1-sample tests with a user specified distribution */	/* Templated constructor for using only with 1-sample tests with a user specified distribution */
	template<class Dist>	template<class Dist>
	GoFTest(UInt_t sampleSize, const Double_t* sample, Dist& dist, EUserDist ribution userDist = kPDF,	GoFTest(UInt_t sampleSize, const Double_t* sample, Dist& dist, EUserDist ribution userDist = kPDF,
	Double_t xmin = 1, Double_t xmax = 0)	Double_t xmin = 1, Double_t xmax = 0)
	{	{
	Instantiate(sample, sampleSize);	Instantiate(sample, sampleSize);
	SetUserDistribution<Dist>(dist, userDist, xmin, xmax);	SetUserDistribution<Dist>(dist, userDist, xmin, xmax);
	}	}


	/* specializetion using IGenFunction interface */	/* Specialization using IGenFunction interface */
	GoFTest(UInt_t sampleSize, const Double_t* sample, const IGenFunction& d ist, EUserDistribution userDist = kPDF,	GoFTest(UInt_t sampleSize, const Double_t* sample, const IGenFunction& d ist, EUserDistribution userDist = kPDF,
	Double_t xmin = 1, Double_t xmax = 0)	Double_t xmin = 1, Double_t xmax = 0)
	{	{
	Instantiate(sample, sampleSize);	Instantiate(sample, sampleSize);

	SetUserDistribution(dist, userDist,xmin,xmax);	SetUserDistribution(dist, userDist, xmin, xmax);
	}	}

	/* Sets the user input distribution function for 1-sample tests. */	/* Sets the user input distribution function for 1-sample tests. */
	template<class Dist>	template<class Dist>
	void SetUserDistribution(Dist& dist, EUserDistribution userDist = kPDF, Double_t xmin = 1, Double_t xmax = 0) {	void SetUserDistribution(Dist& dist, EUserDistribution userDist = kPDF, Double_t xmin = 1, Double_t xmax = 0) {

	WrappedFunction<Dist&> wcdf(dist);	WrappedFunction<Dist&> wdist(dist);
	SetDistributionFunction(wcdf, userDist,xmin,xmax);	SetDistributionFunction(wdist, userDist, xmin, xmax);
	}	}

	/* Template specialization to set the user input distribution for 1-samp le tests */	/* Template specialization to set the user input distribution for 1-samp le tests */

	void SetUserDistribution(const IGenFunction& f, GoFTest::EUserDistributi	void SetUserDistribution(const IGenFunction& dist, GoFTest::EUserDistrib
	on userDist, Double_t xmin = 1, Double_t xmax = 0) {	ution userDist = kPDF, Double_t xmin = 1, Double_t xmax = 0) {
	SetDistributionFunction(f, userDist,xmin,xmax);	SetDistributionFunction(dist, userDist, xmin, xmax);
	}	}

	/* Sets the user input distribution as a probability density function fo r 1-sample tests */	/* Sets the user input distribution as a probability density function fo r 1-sample tests */
	template<class Dist>	template<class Dist>

	void SetUserPDF(Dist& dist, Double_t xmin = 1, Double_t xmax = 0) {	void SetUserPDF(Dist& pdf, Double_t xmin = 1, Double_t xmax = 0) {
	SetUserDistribution<Dist>(dist, kPDF,xmin,xmax);	SetUserDistribution<Dist>(pdf, kPDF, xmin, xmax);
	}	}

	/* Template specialization to set the user input distribution as a proba bility density function for 1-sample tests */	/* Template specialization to set the user input distribution as a proba bility density function for 1-sample tests */

	void SetUserPDF(const IGenFunction& f, Double_t xmin = 1, Double_t xmax	void SetUserPDF(const IGenFunction& pdf, Double_t xmin = 1, Double_t xma
	= 0) {	x = 0) {
	SetUserDistribution(f, kPDF,xmin,xmax);	SetUserDistribution(pdf, kPDF, xmin, xmax);
	}	}

	/* Sets the user input distribution as a cumulative distribution functio n for 1-sample tests	/* Sets the user input distribution as a cumulative distribution functio n for 1-sample tests
	The CDF must return zero	The CDF must return zero
	*/	*/
	template<class Dist>	template<class Dist>

	void SetUserCDF(Dist& dist, Double_t xmin = 1, Double_t xmax = 0) {	void SetUserCDF(Dist& cdf, Double_t xmin = 1, Double_t xmax = 0) {
	SetUserDistribution<Dist>(dist, kCDF, xmin, xmax);	SetUserDistribution<Dist>(cdf, kCDF, xmin, xmax);
	}	}

	/* Template specialization to set the user input distribution as a cumul ative distribution function for 1-sample tests */	/* Template specialization to set the user input distribution as a cumul ative distribution function for 1-sample tests */

	void SetUserCDF(const IGenFunction& f, Double_t xmin = 1, Double_t xmax	void SetUserCDF(const IGenFunction& cdf, Double_t xmin = 1, Double_t xma
	= 0) {	x = 0) {
	SetUserDistribution(f, kCDF, xmin, xmax);	SetUserDistribution(cdf, kCDF, xmin, xmax);
	}	}

	/* Sets the distribution for the predefined distribution types */	/* Sets the distribution for the predefined distribution types */
	void SetDistribution(EDistribution dist);	void SetDistribution(EDistribution dist);

	virtual ~GoFTest();	virtual ~GoFTest();

	/*	/*
	The Anderson-Darling K-Sample Test algorithm is described and taken from	The Anderson-Darling K-Sample Test algorithm is described and taken from
	http://www.itl.nist.gov/div898/software/dataplot/refman1/auxillar/andeksa m.htm	http://www.itl.nist.gov/div898/software/dataplot/refman1/auxillar/andeksa m.htm
	and described and taken from (1)	and described and taken from (1)
	Scholz F.W., Stephens M.A. (1987), K-sample Anderson-Darling Tests, Journ al of the American Statistical Association, 82, 918–924. (2-samples variant implemented)	Scholz F.W., Stephens M.A. (1987), K-sample Anderson-Darling Tests, Journ al of the American Statistical Association, 82, 918–924. (2-samples variant implemented)

	*/	*/ void AndersonDarling2SamplesTest(Double_t& pvalue, Double_t& testStat) c onst;
	Double_t AndersonDarling2SamplesTest(const Char_t* option = "p") const; // Returns default p-value; option "t" returns the test statistic value "A2 "	Double_t AndersonDarling2SamplesTest(const Char_t* option = "p") const; // Returns default p-value; option "t" returns the test statistic value "A2 "

	/*	/*
	The Anderson-Darling 1-Sample Test algorithm for a specific distribution is described at	The Anderson-Darling 1-Sample Test algorithm for a specific distribution is described at
	http://www.itl.nist.gov/div898/software/dataplot/refman1/auxillar/andedar l.htm	http://www.itl.nist.gov/div898/software/dataplot/refman1/auxillar/andedar l.htm
	and described and taken from (2)	and described and taken from (2)
	Marsaglia J.C.W., Marsaglia G. (2004), Evaluating the Anderson-Darling Di stribution, Journal of Statistical Software, Volume 09, Issue i02.	Marsaglia J.C.W., Marsaglia G. (2004), Evaluating the Anderson-Darling Di stribution, Journal of Statistical Software, Volume 09, Issue i02.
	and described and taken from (3)	and described and taken from (3)
	Lewis P.A.W. (1961), The Annals of Mathematical Statistics, Distribution of the Anderson-Darling Statistic, Volume 32, Number 4, 1118-1124.	Lewis P.A.W. (1961), The Annals of Mathematical Statistics, Distribution of the Anderson-Darling Statistic, Volume 32, Number 4, 1118-1124.

	*/	*/ void AndersonDarlingTest(Double_t& pvalue, Double_t& testStat) const;
	Double_t AndersonDarlingTest(const Char_t* option = "p") const; // Retur ns default p-value; option "t" returns the test statistic value "A2"	Double_t AndersonDarlingTest(const Char_t* option = "p") const; // Retur ns default p-value; option "t" returns the test statistic value "A2"

	/*	/*
	The Kolmogorov-Smirnov 2-Samples Test algorithm is described at	The Kolmogorov-Smirnov 2-Samples Test algorithm is described at
	http://www.itl.nist.gov/div898/software/dataplot/refman1/auxillar/ks2samp .htm	http://www.itl.nist.gov/div898/software/dataplot/refman1/auxillar/ks2samp .htm
	and described and taken from	and described and taken from
	http://root.cern.ch/root/html/TMath.html#TMath:KolmogorovTest	http://root.cern.ch/root/html/TMath.html#TMath:KolmogorovTest

	*/	*/ void KolmogorovSmirnov2SamplesTest(Double_t& pvalue, Double_t& testStat) const;
	Double_t KolmogorovSmirnov2SamplesTest(const Char_t* option = "p") const ; // Returns default p-value; option "t" returns the test statistic value " Dn"	Double_t KolmogorovSmirnov2SamplesTest(const Char_t* option = "p") const ; // Returns default p-value; option "t" returns the test statistic value " Dn"

	/*	/*
	The Kolmogorov-Smirnov 1-Sample Test algorithm for a specific distributio n is described at	The Kolmogorov-Smirnov 1-Sample Test algorithm for a specific distributio n is described at
	http://www.itl.nist.gov/div898/software/dataplot/refman1/auxillar/kstest. htm	http://www.itl.nist.gov/div898/software/dataplot/refman1/auxillar/kstest. htm
	and described and taken from (4)	and described and taken from (4)
	Press W. H., Teukolsky S.A., Vetterling W.T., Flannery B.P. (2007), Numer ical Recipes - The Art of Scientific Computing (Third Edition), Cambridge U niverdity Press	Press W. H., Teukolsky S.A., Vetterling W.T., Flannery B.P. (2007), Numer ical Recipes - The Art of Scientific Computing (Third Edition), Cambridge U niverdity Press

	*/	*/ void KolmogorovSmirnovTest(Double_t& pvalue, Double_t& testStat) const;
	Double_t KolmogorovSmirnovTest(const Char_t* option = "p") const; // Ret urns default p-value; option "t" returns the test statistic value "Dn"	Double_t KolmogorovSmirnovTest(const Char_t* option = "p") const; // Ret urns default p-value; option "t" returns the test statistic value "Dn"


	// The class's unary function	// The class's unary functions
	Double_t operator()(ETestType test = kAD, const Char_t* option = "p") co	void operator()(ETestType test, Double_t& pvalue, Double_t& testStat) co
	nst; // The class's unary function: returns default Anderson Darling 1-Samp	nst;
	le Test and default p-value; option "t" returns the test statistic value sp	Double_t operator()(ETestType test = kAD, const Char_t* option = "p") co
	ecific to the test type	nst; // Returns default Anderson Darling 1-Sample Test and default p-value;
		option "t" returns the test statistic value specific to the test type

	private:	private:

	GoFTest(); // Disallowed default constructor	GoFTest(); // Disallowed default constructor
	GoFTest(GoFTest& gof); // Disallowed copy constructor	GoFTest(GoFTest& gof); // Disallowed copy constructor
	GoFTest operator=(GoFTest& gof); // Disallowed assign operator	GoFTest operator=(GoFTest& gof); // Disallowed assign operator

	std::auto_ptr<IGenFunction> fCDF;	std::auto_ptr<IGenFunction> fCDF;

	EDistribution fDist;	EDistribution fDist;

End of changes. 16 change blocks.
	29 lines changed or deleted	30 lines changed or added

	HybridCalculator.h	HybridCalculator.h

	// @(#)root/roostats:$Id: HybridCalculator.h 34109 2010-06-24 15:00:16Z mon	// @(#)root/roostats:$Id: HybridCalculator.h 37084 2010-11-29 21:37:13Z mon
	eta $	eta $
	// Author: Kyle Cranmer, Sven Kreiss 23/05/10
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, 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 ROOSTATS_HybridCalculator	#ifndef ROOSTATS_HybridCalculator
	#define ROOSTATS_HybridCalculator	#define ROOSTATS_HybridCalculator


	#ifndef ROOT_Rtypes	//_________________________________________________
	#include "Rtypes.h" // necessary for TNamed	/*
	#endif	BEGIN_HTML
		<p>
	#ifndef ROOSTATS_HypoTestCalculator	This class extends the HybridCalculator with Importance Sampling. The use
	#include "RooStats/HypoTestCalculator.h"	of ToyMCSampler as the TestStatSampler is assumed.
	#endif	</p>
		END_HTML
	#ifndef ROOSTATS_ModelConfig	*/
	#include "RooStats/ModelConfig.h"	//
	#endif

	#ifndef ROOSTATS_TestStatistic
	#include "RooStats/TestStatistic.h"
	#endif


	#ifndef ROOSTATS_TestStatSampler	#ifndef ROOSTATS_HybridCalculatorGeneric
	#include "RooStats/TestStatSampler.h"	#include "RooStats/HybridCalculatorGeneric.h"
	#endif	#endif


	#ifndef ROOSTATS_SamplingDistribution	#ifndef ROOSTATS_ToyMCSampler
	#include "RooStats/SamplingDistribution.h"	#include "RooStats/ToyMCSampler.h"
	#endif

	#ifndef ROOSTATS_HypoTestResult
	#include "RooStats/HypoTestResult.h"
	#endif	#endif

	namespace RooStats {	namespace RooStats {


	class HybridCalculator: public HypoTestCalculator {	class HybridCalculator: public HybridCalculatorGeneric {

	public:	public:
	HybridCalculator(	HybridCalculator(

	RooAbsData &data,	const RooAbsData &data,
	ModelConfig &altModel,	const ModelConfig &altModel,
	ModelConfig &nullModel,	const ModelConfig &nullModel,
	TestStatSampler* sampler=0	TestStatSampler* sampler=0
	);	) :
		HybridCalculatorGeneric(data, altModel, nullModel, sampler),
		fNullImportanceDensity(NULL),
		fNullImportanceSnapshot(NULL),
		fAltImportanceDensity(NULL),
		fAltImportanceSnapshot(NULL),
		fNToysNull(0),
		fNToysAlt(0),
		fNToysNullTail(0),
		fNToysAltTail(0)
		{
		}

		~HybridCalculator() {
		if(fNullImportanceSnapshot) delete fNullImportanceSnapshot;
		if(fAltImportanceSnapshot) delete fAltImportanceSnapshot;
		}

		// sets importance density and snapshot (optional)
		void SetNullImportanceDensity(RooAbsPdf p, const RooArgSet s = NULL
		) {
		fNullImportanceDensity = p;
		if(s) fNullImportanceSnapshot = (RooArgSet*)s->snapshot();
		else fNullImportanceSnapshot = NULL;
		}

		// sets importance density and snapshot (optional)
		void SetAltImportanceDensity(RooAbsPdf p, const RooArgSet s = NULL)
		{
		fAltImportanceDensity = p;
		if(s) fAltImportanceSnapshot = (RooArgSet*)s->snapshot();
		else fAltImportanceSnapshot = NULL;
		}


	~HybridCalculator();	// set number of toys
		void SetToys(int toysNull, int toysAlt) { fNToysNull = toysNull; fNTo
		ysAlt = toysAlt; }


	public:	// set least number of toys in tails
		void SetNToysInTails(int toysNull, int toysAlt) { fNToysNullTail = to
		ysNull; fNToysAltTail = toysAlt; }


	/// inherited methods from HypoTestCalculator interface	protected:
	virtual HypoTestResult* GetHypoTest() const;	// configure TestStatSampler for the Null run
		int PreNullHook(double obsTestStat) const;


	// set the model for the null hypothesis (only B)	// configure TestStatSampler for the Alt run
	virtual void SetNullModel(const ModelConfig &nullModel) { fNullModel	int PreAltHook(double obsTestStat) const;
	= nullModel; }
	// set the model for the alternate hypothesis (S+B)
	virtual void SetAlternateModel(const ModelConfig &altModel) { fAltMod
	el = altModel; }
	// Set the DataSet
	virtual void SetData(RooAbsData &data) { fData = data; }

	// Override the distribution used for marginalizing nuisance paramete
	rs that is infered from ModelConfig
	virtual void ForcePriorNuisanceNull(RooAbsPdf& priorNuisance) { fPrio
	rNuisanceNull = &priorNuisance; }
	virtual void ForcePriorNuisanceAlt(RooAbsPdf& priorNuisance) { fPrior
	NuisanceAlt = &priorNuisance; }

	// Returns instance of TestStatSampler. Use to change properties of
	// TestStatSampler, e.g. GetTestStatSampler.SetTestSize(Double_t size
	);
	TestStatSampler* GetTestStatSampler(void) { return fTestStatSampler;
	}

	private:	private:

	ModelConfig &fAltModel;	RooAbsPdf *fNullImportanceDensity;
	ModelConfig &fNullModel;	const RooArgSet *fNullImportanceSnapshot;
	RooAbsData &fData;	RooAbsPdf *fAltImportanceDensity;
	RooAbsPdf *fPriorNuisanceNull;	const RooArgSet *fAltImportanceSnapshot;
	RooAbsPdf *fPriorNuisanceAlt;
	TestStatSampler* fTestStatSampler;	// different number of toys for null and alt
	TestStatSampler* fDefaultSampler;	int fNToysNull;
	TestStatistic* fDefaultTestStat;	int fNToysAlt;

	void SetupSampler(ModelConfig& model) const;	// adaptive sampling
		int fNToysNullTail;
	protected:	int fNToysAltTail;
	ClassDef(HybridCalculator,1)
	};	protected:
		ClassDef(HybridCalculator,1)
		};
	}	}

	#endif	#endif

End of changes. 11 change blocks.
	71 lines changed or deleted	81 lines changed or added

	HypoTestPlot.h	HypoTestPlot.h

	// @(#)root/roostats:$Id: HypoTestPlot.h 34109 2010-06-24 15:00:16Z moneta $	// @(#)root/roostats:$Id: HypoTestPlot.h 36602 2010-11-11 16:52:13Z moneta $
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, 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 ROOSTATS_HypoTestPlot	#ifndef ROOSTATS_HypoTestPlot
	#define ROOSTATS_HypoTestPlot	#define ROOSTATS_HypoTestPlot

	skipping to change at line 31	skipping to change at line 31
	#ifndef ROOSTATS_HypoTestResult	#ifndef ROOSTATS_HypoTestResult
	#include "RooStats/HypoTestResult.h"	#include "RooStats/HypoTestResult.h"
	#endif	#endif

	namespace RooStats {	namespace RooStats {

	class HypoTestPlot: public SamplingDistPlot {	class HypoTestPlot: public SamplingDistPlot {
	public:	public:
	/// Constructor	/// Constructor
	HypoTestPlot(HypoTestResult& result, Int_t bins=100);	HypoTestPlot(HypoTestResult& result, Int_t bins=100);

	~HypoTestPlot(void) { if(fTsDataDistr) delete fTsDataDistr; }	~HypoTestPlot(void) {}

	// Applies a HypoTestResult.	// Applies a HypoTestResult.
	void ApplyResult(HypoTestResult& result);	void ApplyResult(HypoTestResult& result);
	// Set default style options (also called in the constructor that tak es a HypoTestResult).	// Set default style options (also called in the constructor that tak es a HypoTestResult).
	void ApplyDefaultStyle(void);	void ApplyDefaultStyle(void);

	private:	private:
	HypoTestResult *fHypoTestResult;	HypoTestResult *fHypoTestResult;

	SamplingDistribution *fTsDataDistr; // to visualize the value of the test statistic evaluated on the data

	protected:	protected:
	ClassDef(HypoTestPlot,1)	ClassDef(HypoTestPlot,1)
	};	};
	}	}

	#endif	#endif

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

	IMethod.h	IMethod.h

	// @(#)root/tmva $Id: IMethod.h 35729 2010-09-25 10:43:37Z stelzer $	// @(#)root/tmva $Id: IMethod.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : IMethod *	* Class : IMethod *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Interface for all concrete MVA method implementations *	* Interface for all concrete MVA method implementations *

	skipping to change at line 77	skipping to change at line 77
	IMethod() {}	IMethod() {}

	// default destructur	// default destructur
	virtual ~IMethod() {}	virtual ~IMethod() {}

	// ------- virtual member functions to be implemented by each MVA met hod	// ------- virtual member functions to be implemented by each MVA met hod
	// the name of the method	// the name of the method
	virtual const char *GetName() const = 0;	virtual const char *GetName() const = 0;

	// calculate the MVA value - some methods may return a per-event erro r estimate (unless: *err = -1)	// calculate the MVA value - some methods may return a per-event erro r estimate (unless: *err = -1)

	virtual Double_t GetMvaValue( Double_t* err = 0 ) = 0;	virtual Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0 ) = 0;

	// training method	// training method
	virtual void Train( void ) = 0;	virtual void Train( void ) = 0;

	// read weights from output stream	// read weights from output stream
	virtual void ReadWeightsFromStream( std::istream& ) = 0;	virtual void ReadWeightsFromStream( std::istream& ) = 0;

	// write method specific monitoring histograms to target file	// write method specific monitoring histograms to target file
	virtual void WriteMonitoringHistosToFile( void ) const = 0;	virtual void WriteMonitoringHistosToFile( void ) const = 0;


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

	Integrator.h	Integrator.h

	// @(#)root/mathmore:$Id: Integrator.h 34764 2010-08-11 09:43:15Z moneta $	// @(#)root/mathmore:$Id: Integrator.h 36764 2010-11-19 10:02:00Z moneta $
	// Authors: L. Moneta, M. Slawinska 10/2007	// Authors: L. Moneta, M. Slawinska 10/2007

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2007 ROOT Foundation, CERN/PH-SFT *	* Copyright (c) 2007 ROOT Foundation, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for class Integrator	// Header file for class Integrator
	//	//
	//	//
	#ifndef ROOT_Math_Integrator	#ifndef ROOT_Math_Integrator
	#define ROOT_Math_Integrator	#define ROOT_Math_Integrator

	#ifndef ROOT_Math_AllIntegrationTypes	#ifndef ROOT_Math_AllIntegrationTypes
	#include "Math/AllIntegrationTypes.h"	#include "Math/AllIntegrationTypes.h"
	#endif	#endif


		#ifndef ROOT_Math_IntegratorOptions
		#include "Math/IntegratorOptions.h"
		#endif

	#ifndef ROOT_Math_IFunction	#ifndef ROOT_Math_IFunction
	#include "Math/IFunction.h"	#include "Math/IFunction.h"
	#endif	#endif

	#ifndef ROOT_Math_VirtualIntegrator	#ifndef ROOT_Math_VirtualIntegrator
	#include "Math/VirtualIntegrator.h"	#include "Math/VirtualIntegrator.h"
	#endif	#endif

	#include <memory>	#include <memory>


	skipping to change at line 75	skipping to change at line 79
	<A HREF="http://www.gnu.org/software/gsl/manual/gsl-ref_16.html#SEC248">GSL Manual</A>.	<A HREF="http://www.gnu.org/software/gsl/manual/gsl-ref_16.html#SEC248">GSL Manual</A>.

	@ingroup Integration	@ingroup Integration

	*/	*/

	class IntegratorOneDim {	class IntegratorOneDim {

	public:	public:


		typedef IntegrationOneDim::Type Type; // for the enumerations defining
		the types

	// constructors	// constructors

	/**	/**
	Constructor of one dimensional Integrator, default type is adaptive	Constructor of one dimensional Integrator, default type is adaptive

	@param type integration type (adaptive, non-adaptive, etc..)	@param type integration type (adaptive, non-adaptive, etc..)
	@param absTol desired absolute Error	@param absTol desired absolute Error
	@param relTol desired relative Error	@param relTol desired relative Error
	@param size maximum number of sub-intervals	@param size maximum number of sub-intervals
	@param rule Gauss-Kronrod integration rule (only for GSL kADAPTIVE type)	@param rule Gauss-Kronrod integration rule (only for GSL kADAPTIVE type)

	Possible type values are : kGAUSS (simple Gauss method), kADAPTIVE ( from GSL), kADAPTIVESINGULAR (from GSL), kNONADAPTIVE (from GSL)	Possible type values are : kGAUSS (simple Gauss method), kADAPTIVE ( from GSL), kADAPTIVESINGULAR (from GSL), kNONADAPTIVE (from GSL)
	Possible rule values are kGAUS15 (rule = 1), kGAUS21( rule = 2), kGA US31(rule =3), kGAUS41 (rule=4), kGAUS51 (rule =5), kGAUS61(rule =6)	Possible rule values are kGAUS15 (rule = 1), kGAUS21( rule = 2), kGA US31(rule =3), kGAUS41 (rule=4), kGAUS51 (rule =5), kGAUS61(rule =6)
	lower rules are indicated for singular functions while higher for sm ooth functions to get better accuracies	lower rules are indicated for singular functions while higher for sm ooth functions to get better accuracies


		NOTE: When the default values are passed, the values used are taken
		from the default defined in ROOT::Math::IntegratorOneDimOptions
	*/	*/
	explicit	explicit

	IntegratorOneDim(IntegrationOneDim::Type type = IntegrationOneDim::kADA PTIVESINGULAR, double absTol = 1.E-9, double relTol = 1E-6, unsigned int si ze = 1000, unsigned int rule = 3) :	IntegratorOneDim(IntegrationOneDim::Type type = IntegrationOneDim::kDEF AULT, double absTol = 0, double relTol = 0, unsigned int size = 0, unsigned int rule = 0) :
	fIntegrator(0), fFunc(0)	fIntegrator(0), fFunc(0)
	{	{
	fIntegrator = CreateIntegrator(type, absTol, relTol, size, rule);	fIntegrator = CreateIntegrator(type, absTol, relTol, size, rule);
	}	}

	/**	/**
	Constructor of one dimensional Integrator passing a function interfa ce	Constructor of one dimensional Integrator passing a function interfa ce

	@param f integration function (1D interface). It is copied insi de	@param f integration function (1D interface). It is copied insi de
	@param type integration type (adaptive, non-adaptive, etc..)	@param type integration type (adaptive, non-adaptive, etc..)
	@param absTol desired absolute Error	@param absTol desired absolute Error
	@param relTol desired relative Error	@param relTol desired relative Error
	@param size maximum number of sub-intervals	@param size maximum number of sub-intervals
	@param rule Gauss-Kronrod integration rule (only for GSL ADAPTIVE ty pe)	@param rule Gauss-Kronrod integration rule (only for GSL ADAPTIVE ty pe)


		NOTE: When the default values are passed, the values used are taken
		from the default defined in ROOT::Math::IntegratorOneDimOptions
	*/	*/
	explicit	explicit

	IntegratorOneDim(const IGenFunction &f, IntegrationOneDim::Type type = I ntegrationOneDim::kADAPTIVE, double absTol = 1.E-9, double relTol = 1E-6, u nsigned int size = 1000, int rule = 3) :	IntegratorOneDim(const IGenFunction &f, IntegrationOneDim::Type type = I ntegrationOneDim::kDEFAULT, double absTol = 0, double relTol = 0, unsigned int size = 0, int rule = 0) :
	fIntegrator(0), fFunc(0)	fIntegrator(0), fFunc(0)
	{	{
	fIntegrator = CreateIntegrator(type, absTol, relTol, size, rule);	fIntegrator = CreateIntegrator(type, absTol, relTol, size, rule);
	SetFunction(f,true);	SetFunction(f,true);
	}	}

	/**	/**
	Template Constructor of one dimensional Integrator passing a generi c function object	Template Constructor of one dimensional Integrator passing a generi c function object

	@param f integration function (any C++ callable object implemen ting operator()(double x)	@param f integration function (any C++ callable object implemen ting operator()(double x)
	@param type integration type (adaptive, non-adaptive, etc..)	@param type integration type (adaptive, non-adaptive, etc..)
	@param absTol desired absolute Error	@param absTol desired absolute Error
	@param relTol desired relative Error	@param relTol desired relative Error
	@param size maximum number of sub-intervals	@param size maximum number of sub-intervals
	@param rule Gauss-Kronrod integration rule (only for GSL ADAPTIVE ty pe)	@param rule Gauss-Kronrod integration rule (only for GSL ADAPTIVE ty pe)
	*/	*/

	template<class Function>	template<class Function>
	explicit	explicit

	IntegratorOneDim(Function & f, IntegrationOneDim::Type type = Integratio nOneDim::kADAPTIVE, double absTol = 1.E-9, double relTol = 1E-6, unsigned i nt size = 1000, int rule = 3) :	IntegratorOneDim(Function & f, IntegrationOneDim::Type type = Integratio nOneDim::kDEFAULT, double absTol = 0, double relTol = 0, unsigned int size = 0, int rule = 0) :
	fIntegrator(0), fFunc(0)	fIntegrator(0), fFunc(0)
	{	{
	fIntegrator = CreateIntegrator(type, absTol, relTol, size, rule);	fIntegrator = CreateIntegrator(type, absTol, relTol, size, rule);
	SetFunction(f);	SetFunction(f);
	}	}

	/// destructor (will delete contained pointer)	/// destructor (will delete contained pointer)
	virtual ~IntegratorOneDim() {	virtual ~IntegratorOneDim() {
	if (fIntegrator) delete fIntegrator;	if (fIntegrator) delete fIntegrator;
	}	}

	skipping to change at line 374	skipping to change at line 384
	/**	/**
	return the estimate of the absolute Error of the last Integral calcul ation	return the estimate of the absolute Error of the last Integral calcul ation
	*/	*/
	double Error() const { return fIntegrator == 0 ? 0 : fIntegrator->Error( ); }	double Error() const { return fIntegrator == 0 ? 0 : fIntegrator->Error( ); }

	/**	/**
	return the Error Status of the last Integral calculation	return the Error Status of the last Integral calculation
	*/	*/
	int Status() const { return fIntegrator == 0 ? -1 : fIntegrator->Status( ); }	int Status() const { return fIntegrator == 0 ? -1 : fIntegrator->Status( ); }


		/**
		return number of function evaluations in calculating the integral
		(if integrator do not implement this function returns -1)
		*/
		int NEval() const { return fIntegrator == 0 ? -1 : fIntegrator->NEval();
		}

	// setter for control Parameters (getters are not needed so far )	// setter for control Parameters (getters are not needed so far )

	/**	/**
	set the desired relative Error	set the desired relative Error
	*/	*/
	void SetRelTolerance(double relTolerance) { if (fIntegrator) fIntegrator ->SetRelTolerance(relTolerance); }	void SetRelTolerance(double relTolerance) { if (fIntegrator) fIntegrator ->SetRelTolerance(relTolerance); }

	/**	/**
	set the desired absolute Error	set the desired absolute Error
	*/	*/
	void SetAbsTolerance(double absTolerance) { if (fIntegrator) fIntegrator ->SetAbsTolerance(absTolerance); }	void SetAbsTolerance(double absTolerance) { if (fIntegrator) fIntegrator ->SetAbsTolerance(absTolerance); }

	/**	/**
	return a pointer to integrator object	return a pointer to integrator object
	*/	*/
	VirtualIntegratorOneDim * GetIntegrator() { return fIntegrator; }	VirtualIntegratorOneDim * GetIntegrator() { return fIntegrator; }


		/**
		set the options
		*/
		void SetOptions(const ROOT::Math::IntegratorOneDimOptions & opt) { if (f
		Integrator) fIntegrator->SetOptions(opt); }

		/**
		retrieve the options
		*/
		ROOT::Math::IntegratorOneDimOptions Options() const { return (fIntegrato
		r) ? fIntegrator->Options() : IntegratorOneDimOptions(); }

		/// return name of integrator
		std::string Name() const { return (fIntegrator) ? Options().Integrator()
		: std::string(""); }

		/// static function to get the enumeration from a string
		static IntegrationOneDim::Type GetType(const char * name);

		/// static function to get a string from the enumeration
		static std::string GetName(IntegrationOneDim::Type);

	protected:	protected:

	VirtualIntegratorOneDim * CreateIntegrator(IntegrationOneDim::Type type , double absTol, double relTol, unsigned int size, int rule);	VirtualIntegratorOneDim * CreateIntegrator(IntegrationOneDim::Type type , double absTol, double relTol, unsigned int size, int rule);

	private:	private:

	VirtualIntegratorOneDim * fIntegrator; // pointer to integrator interf ace class	VirtualIntegratorOneDim * fIntegrator; // pointer to integrator interf ace class
	std::auto_ptr<IGenFunction> fFunc; // pointer to owned function	std::auto_ptr<IGenFunction> fFunc; // pointer to owned function

	};	};

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

	IntegratorMultiDim.h	IntegratorMultiDim.h

	skipping to change at line 24	skipping to change at line 24
	#define ROOT_Math_IntegratorMultiDim	#define ROOT_Math_IntegratorMultiDim

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

	#ifndef ROOT_Math_IntegrationTypes	#ifndef ROOT_Math_IntegrationTypes
	#include "Math/AllIntegrationTypes.h"	#include "Math/AllIntegrationTypes.h"
	#endif	#endif


		#ifndef ROOT_Math_IntegratorOptions
		#include "Math/IntegratorOptions.h"
		#endif

	#ifndef ROOT_Math_VirtualIntegrator	#ifndef ROOT_Math_VirtualIntegrator
	#include "Math/VirtualIntegrator.h"	#include "Math/VirtualIntegrator.h"
	#endif	#endif

	#ifndef __CINT__	#ifndef __CINT__

	#ifndef ROOT_Math_WrappedFunction	#ifndef ROOT_Math_WrappedFunction
	#include "Math/WrappedFunction.h"	#include "Math/WrappedFunction.h"
	#endif	#endif


	skipping to change at line 57	skipping to change at line 61
	plug-in manager the MC integration class (ROOT::Math::GSLMCIntegration) from MathMore.	plug-in manager the MC integration class (ROOT::Math::GSLMCIntegration) from MathMore.

	@ingroup Integration	@ingroup Integration

	*/	*/

	class IntegratorMultiDim {	class IntegratorMultiDim {

	public:	public:


		typedef IntegrationMultiDim::Type Type; // for the enumerations defini
		ng the types

	/** Generic constructor of multi dimensional Integrator. By default use s the Adaptive integration method	/** Generic constructor of multi dimensional Integrator. By default use s the Adaptive integration method

	@param type integration type (adaptive, MC methods, etc..)	@param type integration type (adaptive, MC methods, etc..)
	@param absTol desired absolute Error	@param absTol desired absolute Error
	@param relTol desired relative Error	@param relTol desired relative Error
	@param size maximum number of sub-intervals	@param size maximum number of sub-intervals


		In case no parameter values are passed the default ones used in Int
		egratorMultiDimOptions are used
	*/	*/
	explicit	explicit

	IntegratorMultiDim(IntegrationMultiDim::Type type = IntegrationMultiDim: :kADAPTIVE, double absTol = 1.E-9, double relTol = 1E-6, unsigned int ncall = 100000) :	IntegratorMultiDim(IntegrationMultiDim::Type type = IntegrationMultiDim: :kDEFAULT, double absTol = 0, double relTol = 0, unsigned int ncall = 0) :
	fIntegrator(0), fFunc(0)	fIntegrator(0), fFunc(0)
	{	{
	fIntegrator = CreateIntegrator(type, absTol, relTol, ncall);	fIntegrator = CreateIntegrator(type, absTol, relTol, ncall);
	}	}

	/** Generic Constructor of multi dimensional Integrator passing a funct ion. By default uses the adaptive integration method	/** Generic Constructor of multi dimensional Integrator passing a funct ion. By default uses the adaptive integration method

	@param f integration function (multi-dim interface)	@param f integration function (multi-dim interface)
	@param type integration type (adaptive, MC methods, etc..)	@param type integration type (adaptive, MC methods, etc..)
	@param absTol desired absolute Error	@param absTol desired absolute Error
	@param relTol desired relative Error	@param relTol desired relative Error
	@param ncall number of function calls (apply only to MC integratioo n methods)	@param ncall number of function calls (apply only to MC integratioo n methods)
	*/	*/
	explicit	explicit

	IntegratorMultiDim(const IMultiGenFunction &f, IntegrationMultiDim::Type type = IntegrationMultiDim::kADAPTIVE, double absTol = 1.E-9, double relTo l = 1E-6, unsigned int ncall = 100000) :	IntegratorMultiDim(const IMultiGenFunction &f, IntegrationMultiDim::Type type = IntegrationMultiDim::kDEFAULT, double absTol = 0, double relTol = 0 , unsigned int ncall = 0) :
	fIntegrator(0), fFunc(0)	fIntegrator(0), fFunc(0)
	{	{
	fIntegrator = CreateIntegrator(type, absTol, relTol, ncall);	fIntegrator = CreateIntegrator(type, absTol, relTol, ncall);
	SetFunction(f);	SetFunction(f);
	}	}

	// remove template constructor since is ambigous	// remove template constructor since is ambigous

	/** Template Constructor of multi dimensional Integrator passing a gene ric function. By default uses the adaptive integration method	/** Template Constructor of multi dimensional Integrator passing a gene ric function. By default uses the adaptive integration method


	skipping to change at line 171	skipping to change at line 179

	// return number of function evaluations in calculating the integral	// return number of function evaluations in calculating the integral
	//unsigned int NEval() const { return fNEval; }	//unsigned int NEval() const { return fNEval; }

	/// set the relative tolerance	/// set the relative tolerance
	void SetRelTolerance(double relTol) { if (fIntegrator) fIntegrator->SetR elTolerance(relTol); }	void SetRelTolerance(double relTol) { if (fIntegrator) fIntegrator->SetR elTolerance(relTol); }

	/// set absolute tolerance	/// set absolute tolerance
	void SetAbsTolerance(double absTol) { if (fIntegrator) fIntegrator->Set AbsTolerance(absTol); }	void SetAbsTolerance(double absTol) { if (fIntegrator) fIntegrator->Set AbsTolerance(absTol); }


		/// set the options
		void SetOptions(const ROOT::Math::IntegratorMultiDimOptions & opt) { if
		(fIntegrator) fIntegrator->SetOptions(opt); }

		/// retrieve the options
		ROOT::Math::IntegratorMultiDimOptions Options() const { return (fIntegra
		tor) ? fIntegrator->Options() : IntegratorMultiDimOptions(); }

	/// return a pointer to integrator object	/// return a pointer to integrator object
	VirtualIntegratorMultiDim * GetIntegrator() { return fIntegrator; }	VirtualIntegratorMultiDim * GetIntegrator() { return fIntegrator; }


		/// return name of integrator
		std::string Name() const { return (fIntegrator) ? Options().Integrator()
		: std::string(""); }

		/// static function to get the enumeration from a string
		static IntegrationMultiDim::Type GetType(const char * name);

		/// static function to get a string from the enumeration
		static std::string GetName(IntegrationMultiDim::Type);

	protected:	protected:

	VirtualIntegratorMultiDim * CreateIntegrator(IntegrationMultiDim::Type t ype , double absTol, double relTol, unsigned int ncall);	VirtualIntegratorMultiDim * CreateIntegrator(IntegrationMultiDim::Type t ype , double absTol, double relTol, unsigned int ncall);

	private:	private:

	VirtualIntegratorMultiDim * fIntegrator; // pointer to multi-dimensi onal integrator base class	VirtualIntegratorMultiDim * fIntegrator; // pointer to multi-dimensi onal integrator base class
	std::auto_ptr<IMultiGenFunction> fFunc; // pointer to owned functi on	std::auto_ptr<IMultiGenFunction> fFunc; // pointer to owned functi on

	};	};

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

	Interval.h	Interval.h

	// @(#)root/tmva $Id: Interval.h 33928 2010-06-15 16:19:31Z stelzer $	// @(#)root/tmva $Id: Interval.h 37399 2010-12-08 15:22:07Z evt $
	// Author: Peter Speckmayer	// Author: Peter Speckmayer

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : Interval *	* Class : Interval *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Generic range definition (used, eg, in genetic algorithm) *	* Generic range definition (used, eg, in genetic algorithm) *

	skipping to change at line 28	skipping to change at line 28
	* MPI-K Heidelberg, Germany *	* MPI-K Heidelberg, Germany *
	* *	* *
	* Redistribution and use in source and binary forms, with or without *	* Redistribution and use in source and binary forms, with or without *
	* modification, are permitted according to the terms listed in LICENSE *	* modification, are permitted according to the terms listed in LICENSE *
	* (http://tmva.sourceforge.net/LICENSE) *	* (http://tmva.sourceforge.net/LICENSE) *
	************************************************************************ ******/	************************************************************************ ******/

	#ifndef ROOT_TMVA_Interval	#ifndef ROOT_TMVA_Interval
	#define ROOT_TMVA_Interval	#define ROOT_TMVA_Interval


	//////////////////////////////////////////////////////////////////////////	///////////////////////////////////////////////////////////////////////////
	// //	///
	// Interval //	//
	// //	//
	// Interval definition, continuous and discrete //	// Interval
	// //	//
	//////////////////////////////////////////////////////////////////////////	//
		//
		// Interval definition, continuous and discrete
		//
		//
		//
		// Interval(min,max) : a continous interval [min,max]
		//
		// Interval(min,max,n): a "discrete interval" [min,max], i.e the n numbers:
		//
		// min, min+step, min+2step,...., min+(n-1)step, min+n*step=max
		//
		// e.g.: Interval(1,5,5)=1,2,3,4,5
		//
		// Interval(.5,1.,6)= .5, .6., .7, .8, .9, 1.0
		//
		//
		//
		// Note: bin counting starts from ZERO unlike in ROOT histograms
		//
		//
		//
		// Example: Interval(.5,1.,6)
		//
		//
		//
		// [ min max ]
		//
		// ------------------------------------------------------------
		//
		// \| \| \| \| \| \|
		//
		// .5 .6 .7 .8 .9 1.0
		//
		//
		//
		// bin 0 1 2 3 4 5
		//
		//
		//
		//
		//
		///////////////////////////////////////////////////////////////////////////
		///
	#ifndef ROOT_Rtypes	#ifndef ROOT_Rtypes
	#include "Rtypes.h"	#include "Rtypes.h"
	#endif	#endif

	class TRandom3;	class TRandom3;

	namespace TMVA {	namespace TMVA {

	class MsgLogger;	class MsgLogger;


	skipping to change at line 62	skipping to change at line 79
	virtual ~Interval();	virtual ~Interval();

	// accessors	// accessors
	Double_t GetMin() const { return fMin; }	Double_t GetMin() const { return fMin; }
	Double_t GetMax() const { return fMax; }	Double_t GetMax() const { return fMax; }
	Double_t GetWidth() const { return fMax - fMin; }	Double_t GetWidth() const { return fMax - fMin; }
	Int_t GetNbins() const { return fNbins; }	Int_t GetNbins() const { return fNbins; }
	Double_t GetMean() const { return (fMax + fMin)/2; }	Double_t GetMean() const { return (fMax + fMin)/2; }
	Double_t GetRndm( TRandom3& ) const;	Double_t GetRndm( TRandom3& ) const;
	Double_t GetElement( Int_t position ) const;	Double_t GetElement( Int_t position ) const;

		Double_t GetStepSize() const;

	void SetMax( Double_t m ) { fMax = m; }	void SetMax( Double_t m ) { fMax = m; }
	void SetMin( Double_t m ) { fMin = m; }	void SetMin( Double_t m ) { fMin = m; }

	private:	private:

	Double_t fMin, fMax; // the constraints of the Interval	Double_t fMin, fMax; // the constraints of the Interval
	Int_t fNbins; // when >0 : number of bins (discrete interva l); when =0 continuous interval	Int_t fNbins; // when >0 : number of bins (discrete interva l); when =0 continuous interval

	static MsgLogger* fgLogger; // message logger	static MsgLogger* fgLogger; // message logger

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

	MCParameters.h	MCParameters.h

	// @(#)root/mathmore:$Id: MCParameters.h 21503 2007-12-19 17:34:54Z moneta $	// @(#)root/mathmore:$Id: MCParameters.h 36806 2010-11-20 11:09:14Z moneta $
	// Author: Magdalena Slawinska 08/2007	// Author: Magdalena Slawinska 08/2007

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *
	* *	* *
	* This library is free software; you can redistribute it and/or *	* This library is free software; you can redistribute it and/or *
	* modify it under the terms of the GNU General Public License *	* modify it under the terms of the GNU General Public License *
	* as published by the Free Software Foundation; either version 2 *	* as published by the Free Software Foundation; either version 2 *
	* of the License, or (at your option) any later version. *	* of the License, or (at your option) any later version. *

	skipping to change at line 28	skipping to change at line 28
	* You should have received a copy of the GNU General Public License *	* You should have received a copy of the GNU General Public License *
	* along with this library (see file COPYING); if not, write *	* along with this library (see file COPYING); if not, write *
	* to the Free Software Foundation, Inc., 59 Temple Place, Suite *	* to the Free Software Foundation, Inc., 59 Temple Place, Suite *
	* 330, Boston, MA 02111-1307 USA, or contact the author. *	* 330, Boston, MA 02111-1307 USA, or contact the author. *
	* *	* *
	**********************************************************************/	**********************************************************************/

	#ifndef ROOT_Math_MCParameters	#ifndef ROOT_Math_MCParameters
	#define ROOT_Math_MCParameters	#define ROOT_Math_MCParameters


		#include <cstring> // for size_t

	namespace ROOT {	namespace ROOT {
	namespace Math {	namespace Math {


		class IOptions;

	/**	/**
	structures collecting parameters	structures collecting parameters
	for VEGAS multidimensional integration	for VEGAS multidimensional integration

		FOr implementation of default parameters see file
		mathmore/src/GSLMCIntegrationWorkspace.h

	@ingroup MCIntegration	@ingroup MCIntegration
	*/	*/
	struct VegasParameters{	struct VegasParameters{

	double sigma;	double alpha;
	double chisq;	size_t iterations;
	double alpha;	int stage;
	size_t iterations;	int mode;
		int verbose;
	VegasParameters():
	alpha( 1.5),	// constructor of default parameters
	iterations(5)	VegasParameters() { SetDefaultValues(); }
	{}
		// construct from GenAlgoOptions
	//int stage;	// parameter not specified are ignored
	//int mode;	VegasParameters(const ROOT::Math::IOptions & opt);
	//int verbose;
		void SetDefaultValues();


		VegasParameters & operator=(const ROOT::Math::IOptions & opt);

		/// convert to options (return object is managed by the user)
		ROOT::Math::IOptions * operator() () const;
	};	};

	/**	/**
	structures collecting parameters	structures collecting parameters
	for MISER multidimensional integration	for MISER multidimensional integration

	@ingroup MCIntegration	@ingroup MCIntegration
	*/	*/
	struct MiserParameters{	struct MiserParameters{

	double estimate_frac;	double estimate_frac;
	size_t min_calls;	size_t min_calls;
	size_t min_calls_per_bisection;	size_t min_calls_per_bisection;
	double alpha;	double alpha;
		double dither;
	MiserParameters(unsigned int dim):
	estimate_frac(0.1),	// constructor of default parameters
	min_calls(16*dim),	// needs dimension since min_calls = 16 * dim
	min_calls_per_bisection(32*min_calls) ,	MiserParameters(size_t dim=10) { SetDefaultValues(dim); }
	alpha(2.)
	{}	void SetDefaultValues(size_t dim=10);

		// construct from GenAlgoOptions
		// parameter not specified are ignored
		MiserParameters(const ROOT::Math::IOptions & opt, size_t dim = 10);

		MiserParameters & operator=(const ROOT::Math::IOptions & opt);

		/// convert to options (return object is managed by the user)
		ROOT::Math::IOptions * operator() () const;

	};	};

	struct PlainParameters{	struct PlainParameters{


	};	};

	} // namespace Math	} // namespace Math
	} // namespace ROOT	} // namespace ROOT

	#endif	#endif

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

	MaxLikelihoodEstimateTestStat.h	MaxLikelihoodEstimateTestStat.h

	skipping to change at line 42	skipping to change at line 42
	#include "RooStats/TestStatistic.h"	#include "RooStats/TestStatistic.h"
	#include "RooAbsPdf.h"	#include "RooAbsPdf.h"
	#include "RooRealVar.h"	#include "RooRealVar.h"

	namespace RooStats {	namespace RooStats {

	class MaxLikelihoodEstimateTestStat: public TestStatistic {	class MaxLikelihoodEstimateTestStat: public TestStatistic {

	public:	public:


	//__________________________________	//__________________________________
	MaxLikelihoodEstimateTestStat(RooAbsPdf& pdf, RooRealVar& parameter) :	MaxLikelihoodEstimateTestStat() :
	fPdf(pdf),fParameter(parameter), fUpperLimit(true)	fPdf(NULL),fParameter(NULL), fUpperLimit(true)
		{
	{	// constructor
		// fPdf = pdf;
		// fParameter = parameter;
		}
		//__________________________________
		MaxLikelihoodEstimateTestStat(RooAbsPdf& pdf, RooRealVar& parameter) :
		fPdf(&pdf),fParameter(&parameter), fUpperLimit(true)
		{
	// constructor	// constructor
	// fPdf = pdf;	// fPdf = pdf;
	// fParameter = parameter;	// fParameter = parameter;

		}
	}

	//______________________________	//______________________________
	virtual Double_t Evaluate(RooAbsData& data, RooArgSet& /nullPOI/) {	virtual Double_t Evaluate(RooAbsData& data, RooArgSet& /nullPOI/) {

	RooFit::MsgLevel msglevel = RooMsgService::instance().globalKillBelow() ;	RooFit::MsgLevel msglevel = RooMsgService::instance().globalKillBelow() ;
	RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL);	RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL);

	/*	/*
	// this is more straight forward, but produces a lot of messages	// this is more straight forward, but produces a lot of messages
	RooFitResult* res = fPdf.fitTo(data, RooFit::CloneData(kFALSE),RooFit:: Minos(0),RooFit::Hesse(false), RooFit::Save(1),RooFit::PrintLevel(-1),RooFi t::PrintEvalErrors(0));	RooFitResult* res = fPdf.fitTo(data, RooFit::CloneData(kFALSE),RooFit:: Minos(0),RooFit::Hesse(false), RooFit::Save(1),RooFit::PrintLevel(-1),RooFi t::PrintEvalErrors(0));
	RooRealVar* mle = (RooRealVar*) res->floatParsFinal().find(fParameter.G etName());	RooRealVar* mle = (RooRealVar*) res->floatParsFinal().find(fParameter.G etName());
	double ret = mle->getVal();	double ret = mle->getVal();
	delete res;	delete res;
	return ret;	return ret;
	*/	*/


	RooAbsReal* nll = fPdf.createNLL(data, RooFit::CloneData(false));	RooAbsReal* nll = fPdf->createNLL(data, RooFit::CloneData(false));
	RooAbsReal* profile = nll->createProfile(RooArgSet());	RooAbsReal* profile = nll->createProfile(RooArgSet());
	profile->getVal();	profile->getVal();
	RooArgSet* vars = profile->getVariables();	RooArgSet* vars = profile->getVariables();
	RooMsgService::instance().setGlobalKillBelow(msglevel);	RooMsgService::instance().setGlobalKillBelow(msglevel);

	double ret = vars->getRealValue(fParameter.GetName());	double ret = vars->getRealValue(fParameter->GetName());
	delete vars;	delete vars;
	delete nll;	delete nll;
	delete profile;	delete profile;
	return ret;	return ret;

	}	}

	virtual const TString GetVarName() const {	virtual const TString GetVarName() const {

	TString varName = Form("Maximum Likelihood Estimate of %s",fParameter.G etName());	TString varName = Form("Maximum Likelihood Estimate of %s",fParameter-> GetName());
	return varName;	return varName;
	}	}

	virtual void PValueIsRightTail(bool isright) { fUpperLimit = isright; }	virtual void PValueIsRightTail(bool isright) { fUpperLimit = isright; }
	virtual bool PValueIsRightTail(void) const { return fUpperLimit; }	virtual bool PValueIsRightTail(void) const { return fUpperLimit; }

	private:	private:

	RooAbsPdf& fPdf;	RooAbsPdf *fPdf;
	RooRealVar& fParameter;	RooRealVar *fParameter;
	bool fUpperLimit;	bool fUpperLimit;

	protected:	protected:
	ClassDef(MaxLikelihoodEstimateTestStat,1)	ClassDef(MaxLikelihoodEstimateTestStat,1)
	};	};

	}	}

	#endif	#endif

End of changes. 6 change blocks.
	12 lines changed or deleted	18 lines changed or added

	MemberBase.h	MemberBase.h

	// @(#)root/reflex:$Id: MemberBase.h 32228 2010-02-05 16:13:09Z axel $	// @(#)root/reflex:$Id: MemberBase.h 36289 2010-10-11 09:54:28Z axel $
	// Author: Stefan Roiser 2004	// Author: Stefan Roiser 2004

	// Copyright CERN, CH-1211 Geneva 23, 2004-2010, All rights reserved.	// Copyright CERN, CH-1211 Geneva 23, 2004-2010, All rights reserved.
	//	//
	// Permission to use, copy, modify, and distribute this software for any	// Permission to use, copy, modify, and distribute this software for any
	// purpose is hereby granted without fee, provided that this copyright and	// purpose is hereby granted without fee, provided that this copyright and
	// permissions notice appear in all copies and derivatives.	// permissions notice appear in all copies and derivatives.
	//	//
	// This software is provided "as is" without express or implied warranty.	// This software is provided "as is" without express or implied warranty.


	skipping to change at line 323	skipping to change at line 323
	* @link aggregation	* @link aggregation
	* @supplierCardinality 1	* @supplierCardinality 1
	* @clientCardinality 1	* @clientCardinality 1
	*/	*/
	Member* fThisMember;	Member* fThisMember;

	}; // class Member	}; // class Member

	} //namespace Reflex	} //namespace Reflex


		#ifndef Reflex_Object
	#include "Reflex/Object.h"	#include "Reflex/Object.h"

		#endif
		#ifndef Reflex_MemberTemplate
	#include "Reflex/MemberTemplate.h"	#include "Reflex/MemberTemplate.h"

		#endif

	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	inline Reflex::Object	inline Reflex::Object
	Reflex::MemberBase::Get(const Object& /* obj */) const {	Reflex::MemberBase::Get(const Object& /* obj */) const {
	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	return Object();	return Object();
	}	}

	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	//inline Reflex::Object	//inline Reflex::Object

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

	Method.h	Method.h

	skipping to change at line 19	skipping to change at line 19
	************************************************************************	************************************************************************
	* Copyright(c) 1995~2005 Masaharu Goto	* Copyright(c) 1995~2005 Masaharu Goto
	*	*
	* For the licensing terms see the file COPYING	* For the licensing terms see the file COPYING
	*	*
	************************************************************************/	************************************************************************/

	#ifndef G__METHODINFO_H	#ifndef G__METHODINFO_H
	#define G__METHODINFO_H	#define G__METHODINFO_H


		#ifndef G__API_H
	#include "Api.h"	#include "Api.h"

		#endif

	namespace Cint {	namespace Cint {

	/*********************************************************************	/*********************************************************************
	* class G__MethodInfo	* class G__MethodInfo
	*	*
	*	*
	*********************************************************************/	*********************************************************************/
	class	class
	#ifndef __CINT__	#ifndef __CINT__
	G__EXPORT	G__EXPORT
	#endif	#endif
	G__MethodInfo {	G__MethodInfo {
	friend class G__MethodArgInfo;	friend class G__MethodArgInfo;
	public:	public:

	~G__MethodInfo() {}	~G__MethodInfo() { if (memberOf != belongingclass) delete memberOf; }
	G__MethodInfo()	G__MethodInfo()

	: handle(0), index(0), usingIndex(0), belongingclass(NULL), type()	: handle(0), index(0), usingIndex(0), belongingclass(NULL), memberOf(0) , type()
	{ Init(); }	{ Init(); }
	G__MethodInfo(G__ClassInfo &a)	G__MethodInfo(G__ClassInfo &a)

	: handle(0), index(0), usingIndex(0), belongingclass(NULL), type()	: handle(0), index(0), usingIndex(0), belongingclass(NULL), memberOf(0) , type()
	{ Init(a); }	{ Init(a); }
	G__MethodInfo(const G__MethodInfo& mi)	G__MethodInfo(const G__MethodInfo& mi)
	: handle(mi.handle), index(mi.index), usingIndex(mi.usingIndex),	: handle(mi.handle), index(mi.index), usingIndex(mi.usingIndex),

	belongingclass(mi.belongingclass), type(mi.type) {}	belongingclass(mi.belongingclass), memberOf(0), type(mi.type) {}
	G__MethodInfo& operator=(const G__MethodInfo& mi) {	G__MethodInfo& operator=(const G__MethodInfo& mi) {
	handle=mi.handle; index=mi.index; usingIndex=mi.usingIndex;	handle=mi.handle; index=mi.index; usingIndex=mi.usingIndex;

	belongingclass=mi.belongingclass; type=mi.type; return *this;}	belongingclass=mi.belongingclass; memberOf=NULL; type=mi.type; return * this;}

	void Init();	void Init();
	void Init(G__ClassInfo &a);	void Init(G__ClassInfo &a);
	void Init(long handlein,long indexin,G__ClassInfo *belongingclassin);	void Init(long handlein,long indexin,G__ClassInfo *belongingclassin);
	void Init(G__ClassInfo *belongingclassin,long funcpage,long indexin);	void Init(G__ClassInfo *belongingclassin,long funcpage,long indexin);

	const char *Name() ;	const char *Name() ;
	#ifndef __MAKECINT__	#ifndef __MAKECINT__
	int Hash() ;	int Hash() ;
	struct G__ifunc_table* ifunc();	struct G__ifunc_table* ifunc();

	skipping to change at line 75	skipping to change at line 77
	int NDefaultArg();	int NDefaultArg();
	int HasVarArgs();	int HasVarArgs();
	G__InterfaceMethod InterfaceMethod();	G__InterfaceMethod InterfaceMethod();
	#ifdef G__ASM_WHOLEFUNC	#ifdef G__ASM_WHOLEFUNC
	struct G__bytecodefunc *GetBytecode();	struct G__bytecodefunc *GetBytecode();
	#endif	#endif
	G__DataMemberInfo GetLocalVariable(); /* ON1163 */	G__DataMemberInfo GetLocalVariable(); /* ON1163 */
	#ifdef G__TRUEP2F	#ifdef G__TRUEP2F
	void* PointerToFunc();	void* PointerToFunc();
	#endif	#endif

	G__ClassInfo* MemberOf() { return(belongingclass); }	G__ClassInfo* CreatedBy() { return(belongingclass); }
		G__ClassInfo* MemberOf();
	int GetDefiningScopeTagnum();	int GetDefiningScopeTagnum();
	struct G__friendtag* GetFriendInfo();	struct G__friendtag* GetFriendInfo();
	void SetGlobalcomp(int globalcomp);	void SetGlobalcomp(int globalcomp);
	void SetForceStub();	void SetForceStub();
	int IsValid();	int IsValid();
	int SetFilePos(const char* fname);	int SetFilePos(const char* fname);
	int Next();	int Next();

	const char *FileName();	const char *FileName();
	int LineNumber();	int LineNumber();

	skipping to change at line 110	skipping to change at line 113
	void *GetUserParam();	void *GetUserParam();
	long GetThisPointerOffset();	long GetThisPointerOffset();

	protected:	protected:
	long handle;	long handle;
	long index;	long index;
	#ifndef G__OLDIMPLEMENTATION2194	#ifndef G__OLDIMPLEMENTATION2194
	long usingIndex;	long usingIndex;
	#endif	#endif
	G__ClassInfo* belongingclass;	G__ClassInfo* belongingclass;

		G__ClassInfo* memberOf;
	G__TypeInfo type;	G__TypeInfo type;

	};	};

	} // namespace Cint	} // namespace Cint

	using namespace Cint;	using namespace Cint;
	#endif	#endif

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

	MethodAr.h	MethodAr.h

	skipping to change at line 19	skipping to change at line 19
	************************************************************************	************************************************************************
	* Copyright(c) 1995~1999 Masaharu Goto	* Copyright(c) 1995~1999 Masaharu Goto
	*	*
	* For the licensing terms see the file COPYING	* For the licensing terms see the file COPYING
	*	*
	************************************************************************/	************************************************************************/

	#ifndef G__METHODARGINFO_H	#ifndef G__METHODARGINFO_H
	#define G__METHODARGINFO_H	#define G__METHODARGINFO_H


		#ifndef G__API_H
	#include "Api.h"	#include "Api.h"

		#endif

	namespace Cint {	namespace Cint {

	/*********************************************************************	/*********************************************************************
	* class G__MethodArgInfo	* class G__MethodArgInfo
	*	*
	*	*
	*********************************************************************/	*********************************************************************/
	class	class
	#ifndef __CINT__	#ifndef __CINT__

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

	MethodBDT.h	MethodBDT.h

	// @(#)root/tmva $Id: MethodBDT.h 33939 2010-06-16 09:44:12Z rdm $	// @(#)root/tmva $Id: MethodBDT.h 37399 2010-12-08 15:22:07Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodBDT (Boosted Decision Trees) *	* Class : MethodBDT (Boosted Decision Trees) *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Analysis of Boosted Decision Trees *	* Analysis of Boosted Decision Trees *

	skipping to change at line 85	skipping to change at line 85
	TDirectory* theTargetDir = NULL );	TDirectory* theTargetDir = NULL );

	virtual ~MethodBDT( void );	virtual ~MethodBDT( void );

	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );

	// write all Events from the Tree into a vector of Events, that are	// write all Events from the Tree into a vector of Events, that are
	// more easily manipulated	// more easily manipulated
	void InitEventSample();	void InitEventSample();


		// optimize tuning parameters
		virtual std::map<TString,Double_t> OptimizeTuningParameters(TString f
		omType="ROCIntegral", TString fitType="FitGA");
		virtual void SetTuneParameters(std::map<TString,Double_t> tuneParamet
		ers);

	// training method	// training method
	void Train( void );	void Train( void );


		// revoke training
		void Reset( void );

	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	// write weights to file	// write weights to file
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( istream& istr );	void ReadWeightsFromStream( istream& istr );
	void ReadWeightsFromXML(void* parent);	void ReadWeightsFromXML(void* parent);

	// write method specific histos to target file	// write method specific histos to target file
	void WriteMonitoringHistosToFile( void ) const;	void WriteMonitoringHistosToFile( void ) const;

	// calculate the MVA value	// calculate the MVA value

	Double_t GetMvaValue( Double_t* err = 0);	Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0);
	Double_t GetMvaValue( Double_t* err , UInt_t useNTrees );
		private:
		Double_t GetMvaValue( Double_t* err, Double_t* errUpper, UInt_t useNT
		rees );

		public:
	const std::vector<Float_t>& GetMulticlassValues();	const std::vector<Float_t>& GetMulticlassValues();

	// regression response	// regression response
	const std::vector<Float_t>& GetRegressionValues();	const std::vector<Float_t>& GetRegressionValues();

	// apply the boost algorithm to a tree in the collection	// apply the boost algorithm to a tree in the collection
	Double_t Boost( std::vector<TMVA::Event>, DecisionTree dt, Int_t iT ree, UInt_t cls = 0);	Double_t Boost( std::vector<TMVA::Event>, DecisionTree dt, Int_t iT ree, UInt_t cls = 0);

	// ranking of input variables	// ranking of input variables
	const Ranking* CreateRanking();	const Ranking* CreateRanking();

	// the option handling methods	// the option handling methods
	void DeclareOptions();	void DeclareOptions();
	void ProcessOptions();	void ProcessOptions();

		void SetMaxDepth(Int_t d){fMaxDepth = d;}
		void SetNodeMinEvents(Int_t d){fNodeMinEvents = d;}
		void SetNTrees(Int_t d){fNTrees = d;}
		void SetAdaBoostBeta(Double_t b){fAdaBoostBeta = b;}
		void SetNodePurityLimit(Double_t l){fNodePurityLimit = l;}

	// get the forest	// get the forest
	inline const std::vector<TMVA::DecisionTree*> & GetForest() const;	inline const std::vector<TMVA::DecisionTree*> & GetForest() const;

	// get the forest	// get the forest
	inline const std::vector<TMVA::Event*> & GetTrainingEvents() const;	inline const std::vector<TMVA::Event*> & GetTrainingEvents() const;

	inline const std::vector<double> & GetBoostWeights() const;	inline const std::vector<double> & GetBoostWeights() const;

	//return the individual relative variable importance	//return the individual relative variable importance

	skipping to change at line 143	skipping to change at line 159
	void MakeClassSpecific( std::ostream&, const TString& ) const;	void MakeClassSpecific( std::ostream&, const TString& ) const;

	// header and auxiliary classes	// header and auxiliary classes
	void MakeClassSpecificHeader( std::ostream&, const TString& ) const;	void MakeClassSpecificHeader( std::ostream&, const TString& ) const;

	void MakeClassInstantiateNode( DecisionTreeNode *n, std::ostream& fou t,	void MakeClassInstantiateNode( DecisionTreeNode *n, std::ostream& fou t,
	const TString& className ) const;	const TString& className ) const;

	void GetHelpMessage() const;	void GetHelpMessage() const;


		virtual Bool_t IsSignalLike() { return GetMvaValue() > 0;}
	protected:	protected:
	void DeclareCompatibilityOptions();	void DeclareCompatibilityOptions();

	private:	private:
	// Init used in the various constructors	// Init used in the various constructors
	void Init( void );	void Init( void );

	// boosting algorithm (adaptive boosting)	// boosting algorithm (adaptive boosting)
	Double_t AdaBoost( std::vector<TMVA::Event>, DecisionTree dt );	Double_t AdaBoost( std::vector<TMVA::Event>, DecisionTree dt );


	skipping to change at line 180	skipping to change at line 197
	Double_t GetGradBoostMVA(TMVA::Event& e, UInt_t nTrees);	Double_t GetGradBoostMVA(TMVA::Event& e, UInt_t nTrees);
	void GetRandomSubSample();	void GetRandomSubSample();
	Double_t GetWeightedQuantile(std::vector<std::pair<Double_t, Double_t > > vec, const Double_t quantile, const Double_t SumOfWeights = 0.0);	Double_t GetWeightedQuantile(std::vector<std::pair<Double_t, Double_t > > vec, const Double_t quantile, const Double_t SumOfWeights = 0.0);

	std::vector<TMVA::Event*> fEventSample; // the training eve nts	std::vector<TMVA::Event*> fEventSample; // the training eve nts
	std::vector<TMVA::Event*> fValidationSample;// the Validation e vents	std::vector<TMVA::Event*> fValidationSample;// the Validation e vents
	std::vector<TMVA::Event*> fSubSample; // subsample for ba gged grad boost	std::vector<TMVA::Event*> fSubSample; // subsample for ba gged grad boost
	Int_t fNTrees; // number of decisi on trees requested	Int_t fNTrees; // number of decisi on trees requested
	std::vector<DecisionTree*> fForest; // the collection o f decision trees	std::vector<DecisionTree*> fForest; // the collection o f decision trees
	std::vector<double> fBoostWeights; // the weights appl ied in the individual boosts	std::vector<double> fBoostWeights; // the weights appl ied in the individual boosts

		Bool_t fRenormByClass; // individually re- normalize each event class to the original size after boosting
	TString fBoostType; // string specifyin g the boost type	TString fBoostType; // string specifyin g the boost type
	Double_t fAdaBoostBeta; // beta parameter f or AdaBoost algorithm	Double_t fAdaBoostBeta; // beta parameter f or AdaBoost algorithm
	TString fAdaBoostR2Loss; // loss type used i n AdaBoostR2 (Linear,Quadratic or Exponential)	TString fAdaBoostR2Loss; // loss type used i n AdaBoostR2 (Linear,Quadratic or Exponential)
	Double_t fTransitionPoint; // break-down point for gradient regression	Double_t fTransitionPoint; // break-down point for gradient regression
	Double_t fShrinkage; // learning rate fo r gradient boost;	Double_t fShrinkage; // learning rate fo r gradient boost;
	Bool_t fBaggedGradBoost; // turn bagging in combination with grad boost on/off	Bool_t fBaggedGradBoost; // turn bagging in combination with grad boost on/off
	Double_t fSampleFraction; // fraction of even ts used for bagged grad boost	Double_t fSampleFraction; // fraction of even ts used for bagged grad boost
	Double_t fSumOfWeights; // sum of all event weights	Double_t fSumOfWeights; // sum of all event weights

	std::vector<std::pair<Double_t, Double_t> > fWeightedResiduals; // weighted regression residuals	std::map< TMVA::Event*, std::pair<Double_t, Double_t> > fWeight edResiduals; // weighted regression residuals
	std::map< TMVA::Event*,std::vector<double> > fResiduals; // individua l event residuals for gradient boost	std::map< TMVA::Event*,std::vector<double> > fResiduals; // individua l event residuals for gradient boost

	//options for the decision Tree	//options for the decision Tree
	SeparationBase *fSepType; // the separation u sed in node splitting	SeparationBase *fSepType; // the separation u sed in node splitting
	TString fSepTypeS; // the separation ( option string) used in node splitting	TString fSepTypeS; // the separation ( option string) used in node splitting
	Int_t fNodeMinEvents; // min number of ev ents in node	Int_t fNodeMinEvents; // min number of ev ents in node

	Int_t fNCuts; // grid used in cut applied in node splitting	Int_t fNCuts; // grid used in cut applied in node splitting

		Bool_t fUseFisherCuts; // use multivariate
		splits using the Fisher criterium
		Double_t fMinLinCorrForFisher; // the minimum
		linear correlation between two variables demanded for use in fisher criteri
		um in node splitting
		Bool_t fUseExclusiveVars; // individual vari
		ables already used in fisher criterium are not anymore analysed individuall
		y for node splitting
	Bool_t fUseYesNoLeaf; // use sig or bkg c lassification in leave nodes or sig/bkg	Bool_t fUseYesNoLeaf; // use sig or bkg c lassification in leave nodes or sig/bkg
	Double_t fNodePurityLimit; // purity limit for sig/bkg nodes	Double_t fNodePurityLimit; // purity limit for sig/bkg nodes
	Bool_t fUseWeightedTrees;// use average clas sification from the trees, or have the individual trees trees in the forest weighted (e.g. log(boostweight) from AdaBoost	Bool_t fUseWeightedTrees;// use average clas sification from the trees, or have the individual trees trees in the forest weighted (e.g. log(boostweight) from AdaBoost
	UInt_t fNNodesMax; // max # of nodes	UInt_t fNNodesMax; // max # of nodes
	UInt_t fMaxDepth; // max depth	UInt_t fMaxDepth; // max depth


	//some histograms for monitoring
	TTree* fMonitorNtuple; // monitoring ntup
	le
	Int_t fITree; // ntuple var: ith
	tree
	Double_t fBoostWeight; // ntuple var: boo
	st weight
	Double_t fErrorFraction; // ntuple var: mis
	classification error fraction
	Double_t fPruneStrength; // a parameter to
	set the "amount" of pruning..needs to be adjusted
	DecisionTree::EPruneMethod fPruneMethod; // method used for prunig	DecisionTree::EPruneMethod fPruneMethod; // method used for prunig
	TString fPruneMethodS; // prune method op tion String	TString fPruneMethodS; // prune method op tion String

		Double_t fPruneStrength; // a parameter to set the "amount" of pruning..needs to be adjusted
	Bool_t fPruneBeforeBoost;// flag to prune b efore boosting	Bool_t fPruneBeforeBoost;// flag to prune b efore boosting
	Double_t fFValidationEvents; // fraction o f events to use for pruning	Double_t fFValidationEvents; // fraction o f events to use for pruning
	Bool_t fAutomatic; // use user given prune strength or automatically determined one using a validation sample	Bool_t fAutomatic; // use user given prune strength or automatically determined one using a validation sample
	Bool_t fRandomisedTrees; // choose a random subset of possible cut variables at each node during training	Bool_t fRandomisedTrees; // choose a random subset of possible cut variables at each node during training
	UInt_t fUseNvars; // the number of v ariables used in the randomised tree splitting	UInt_t fUseNvars; // the number of v ariables used in the randomised tree splitting

		Bool_t fUsePoissonNvars; // use "fUseNvars" not as fixed number but as mean of a possion distr. in each split
	UInt_t fUseNTrainEvents; // number of rando mly picked training events used in randomised (and bagged) trees	UInt_t fUseNTrainEvents; // number of rando mly picked training events used in randomised (and bagged) trees


		Double_t fSampleSizeFraction; // relative siz
		e of bagged event sample to original sample size
		Bool_t fNoNegWeightsInTraining; // ignore n
		egative event weights in the training

		//some histograms for monitoring
		TTree* fMonitorNtuple; // monitoring ntup
		le
		Int_t fITree; // ntuple var: ith
		tree
		Double_t fBoostWeight; // ntuple var: boo
		st weight
		Double_t fErrorFraction; // ntuple var: mis
		classification error fraction

	std::vector<Double_t> fVariableImportance; // the relative importance of the different variables	std::vector<Double_t> fVariableImportance; // the relative importance of the different variables

	// debugging flags	// debugging flags
	static const Int_t fgDebugLevel; // debug level det ermining some printout/control plots etc.	static const Int_t fgDebugLevel; // debug level det ermining some printout/control plots etc.

	// for backward compatibility	// for backward compatibility


	Double_t fSampleSizeFraction; // relative siz
	e of bagged event sample to original sample size
	Bool_t fNoNegWeightsInTraining; // ignore n
	egative event weights in the training

	ClassDef(MethodBDT,0) // Analysis of Boosted Decision Trees	ClassDef(MethodBDT,0) // Analysis of Boosted Decision Trees
	};	};

	} // namespace TMVA	} // namespace TMVA

	const std::vector<TMVA::DecisionTree*>& TMVA::MethodBDT::GetForest() const { return fForest; }	const std::vector<TMVA::DecisionTree*>& TMVA::MethodBDT::GetForest() const { return fForest; }
	const std::vector<TMVA::Event*>& TMVA::MethodBDT::GetTrainingEvents( ) const { return fEventSample; }	const std::vector<TMVA::Event*>& TMVA::MethodBDT::GetTrainingEvents( ) const { return fEventSample; }
	const std::vector<double>& TMVA::MethodBDT::GetBoostWeights() const { return fBoostWeights; }	const std::vector<double>& TMVA::MethodBDT::GetBoostWeights() const { return fBoostWeights; }

	#endif	#endif

End of changes. 14 change blocks.
	20 lines changed or deleted	50 lines changed or added

	MethodBase.h	MethodBase.h

	// @(#)root/tmva $Id: MethodBase.h 35729 2010-09-25 10:43:37Z stelzer $	// @(#)root/tmva $Id: MethodBase.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss, Ka i Voss	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss, Ka i Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodBase *	* Class : MethodBase *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Virtual base class for all MVA method *	* Virtual base class for all MVA method *

	skipping to change at line 44	skipping to change at line 44
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// //	// //
	// MethodBase //	// MethodBase //
	// //	// //
	// Virtual base class for all TMVA method //	// Virtual base class for all TMVA method //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#include <iosfwd>	#include <iosfwd>
	#include <vector>	#include <vector>

		#include <map>
	#include "assert.h"	#include "assert.h"


		#ifndef ROOT_TString
		#include "TString.h"
		#endif

	#ifndef ROOT_TMVA_IMethod	#ifndef ROOT_TMVA_IMethod
	#include "TMVA/IMethod.h"	#include "TMVA/IMethod.h"
	#endif	#endif
	#ifndef ROOT_TMVA_Configurable	#ifndef ROOT_TMVA_Configurable
	#include "TMVA/Configurable.h"	#include "TMVA/Configurable.h"
	#endif	#endif
	#ifndef ROOT_TMVA_Types	#ifndef ROOT_TMVA_Types
	#include "TMVA/Types.h"	#include "TMVA/Types.h"
	#endif	#endif
	#ifndef ROOT_TMVA_DataSet	#ifndef ROOT_TMVA_DataSet
	#include "TMVA/DataSet.h"	#include "TMVA/DataSet.h"
	#endif	#endif
	#ifndef ROOT_TMVA_Event	#ifndef ROOT_TMVA_Event
	#include "TMVA/Event.h"	#include "TMVA/Event.h"
	#endif	#endif
	#ifndef ROOT_TMVA_TransformationHandler	#ifndef ROOT_TMVA_TransformationHandler
	#include "TMVA/TransformationHandler.h"	#include "TMVA/TransformationHandler.h"
	#endif	#endif

		#ifndef ROOT_TMVA_OptimizeConfigParameters
		#include "TMVA/OptimizeConfigParameters.h"
		#endif

	class TGraph;	class TGraph;
	class TTree;	class TTree;
	class TDirectory;	class TDirectory;
	class TSpline;	class TSpline;

	namespace TMVA {	namespace TMVA {

	class Ranking;	class Ranking;
	class PDF;	class PDF;

	skipping to change at line 116	skipping to change at line 124
	virtual void CheckSetup(); // may be overwritten by derived class es	virtual void CheckSetup(); // may be overwritten by derived class es

	// ---------- main training and testing methods --------------------- ---------	// ---------- main training and testing methods --------------------- ---------

	// prepare tree branch with the method's discriminating variable	// prepare tree branch with the method's discriminating variable
	void AddOutput( Types::ETreeType type, Types::EAnalysisTy pe analysisType );	void AddOutput( Types::ETreeType type, Types::EAnalysisTy pe analysisType );

	// performs classifier training	// performs classifier training
	// calls methods Train() implemented by derived classes	// calls methods Train() implemented by derived classes
	void TrainMethod();	void TrainMethod();


		// optimize tuning parameters
		virtual std::map<TString,Double_t> OptimizeTuningParameters(TString f
		omType="ROCIntegral", TString fitType="FitGA");
		virtual void SetTuneParameters(std::map<TString,Double_t> tuneParamet
		ers);

	virtual void Train() = 0;	virtual void Train() = 0;

	// 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; }


	skipping to change at line 146	skipping to change at line 159
	Double_t& mInf, Double_t& mInfT, // mutual information	Double_t& mInf, Double_t& mInfT, // mutual information
	Double_t& corr,	Double_t& corr,
	Types::ETreeType type );	Types::ETreeType type );

	// options treatment	// options treatment
	virtual void Init() = 0;	virtual void Init() = 0;
	virtual void DeclareOptions() = 0;	virtual void DeclareOptions() = 0;
	virtual void ProcessOptions() = 0;	virtual void ProcessOptions() = 0;
	virtual void DeclareCompatibilityOptions(); // declaration of pas t options	virtual void DeclareCompatibilityOptions(); // declaration of pas t options


	// classifier response - some methods may return a per-event error es	// reset the Method --> As if it was not yet trained, just instantiat
	timate (unless: *err = -1)	ed
	virtual Double_t GetMvaValue( Double_t* err = 0 ) = 0;	// virtual void Reset() = 0;
		//for the moment, I provide a dummy (that would not work) default, ju
	//zjh=>	st to make
	virtual Double_t GetMvaValues( Double_t& errUpper, Double_t& errLower	// compilation/running w/o parameter optimisation still possible
	)	virtual void Reset(){return;}
	{Double_t mva=GetMvaValue(&errUpper); errLower=errUpper;re
	turn mva;}	// classifier response:
	//<=zjh	// some methods may return a per-event error estimate
		// error calculation is skipped if err==0
		virtual Double_t GetMvaValue( Double_t* errLower = 0, Double_t* errUp
		per = 0) = 0;

	// signal/background classification response	// signal/background classification response

	Double_t GetMvaValue( const TMVA::Event* const ev, Double_t* err = 0	Double_t GetMvaValue( const TMVA::Event* const ev, Double_t* err = 0,
	);	Double_t* errUpper = 0 );

		protected:
		// helper function to set errors to -1
		void NoErrorCalc(Double_t* const err, Double_t* const errUpper);


		public:
	// regression response	// regression response
	virtual const std::vector<Float_t>& GetRegressionValues() {	virtual const std::vector<Float_t>& GetRegressionValues() {
	std::vector<Float_t>* ptr = new std::vector<Float_t>(0);	std::vector<Float_t>* ptr = new std::vector<Float_t>(0);
	return (*ptr);	return (*ptr);
	}	}

	// multiclass classification response	// multiclass classification response
	virtual const std::vector<Float_t>& GetMulticlassValues() {	virtual const std::vector<Float_t>& GetMulticlassValues() {
	std::vector<Float_t>* ptr = new std::vector<Float_t>(0);	std::vector<Float_t>* ptr = new std::vector<Float_t>(0);
	return (*ptr);	return (*ptr);

	skipping to change at line 220	skipping to change at line 241
	public: // these two need to be public, they are used to read in-memory weight-files	public: // these two need to be public, they are used to read in-memory weight-files
	void ReadStateFromStream ( std::istream& tf ); // backward c ompatibility	void ReadStateFromStream ( std::istream& tf ); // backward c ompatibility
	void ReadStateFromStream ( TFile& rf ); // backward c ompatibility	void ReadStateFromStream ( TFile& rf ); // backward c ompatibility
	void ReadStateFromXMLString( const char* xmlstr ); // for readin g from memory	void ReadStateFromXMLString( const char* xmlstr ); // for readin g from memory

	private:	private:
	// the variable information	// the variable information
	void AddVarsXMLTo ( void* parent ) const;	void AddVarsXMLTo ( void* parent ) const;
	void AddSpectatorsXMLTo ( void* parent ) const;	void AddSpectatorsXMLTo ( void* parent ) const;
	void AddTargetsXMLTo ( void* parent ) const;	void AddTargetsXMLTo ( void* parent ) const;

		void AddClassesXMLTo ( void* parent ) const;
	void ReadVariablesFromXML ( void* varnode );	void ReadVariablesFromXML ( void* varnode );
	void ReadSpectatorsFromXML( void* specnode);	void ReadSpectatorsFromXML( void* specnode);
	void ReadTargetsFromXML ( void* tarnode );	void ReadTargetsFromXML ( void* tarnode );

		void ReadClassesFromXML ( void* clsnode );
	void ReadVarsFromStream ( std::istream& istr ); // backward c ompatibility	void ReadVarsFromStream ( std::istream& istr ); // backward c ompatibility

	public:	public:
	// ------------------------------------------------------------------ ---------	// ------------------------------------------------------------------ ---------

	// write evaluation histograms into target file	// write evaluation histograms into target file
	virtual void WriteEvaluationHistosToFile(Types::ETreeType treetyp e);	virtual void WriteEvaluationHistosToFile(Types::ETreeType treetyp e);

	// write classifier-specific monitoring information to target file	// write classifier-specific monitoring information to target file
	virtual void WriteMonitoringHistosToFile() const;	virtual void WriteMonitoringHistosToFile() const;

	skipping to change at line 246	skipping to change at line 269
	// individual initialistion for testing of each method	// individual initialistion for testing of each method
	// overload this one for individual initialisation of the testing,	// overload this one for individual initialisation of the testing,
	// it is then called automatically within the global "TestInit"	// it is then called automatically within the global "TestInit"

	// variables (and private menber functions) for the Evaluation:	// variables (and private menber functions) for the Evaluation:
	// get the effiency. It fills a histogram for efficiency/vs/bkg	// get the effiency. It fills a histogram for efficiency/vs/bkg
	// and returns the one value fo the efficiency demanded for	// and returns the one value fo the efficiency demanded for
	// in the TString argument. (Watch the string format)	// in the TString argument. (Watch the string format)
	virtual Double_t GetEfficiency( const TString&, Types::ETreeType, Dou ble_t& err );	virtual Double_t GetEfficiency( const TString&, Types::ETreeType, Dou ble_t& err );
	virtual Double_t GetTrainingEfficiency(const TString& );	virtual Double_t GetTrainingEfficiency(const TString& );

		virtual std::vector<Float_t> GetMulticlassEfficiency( std::vector<std
		::vector<Float_t> >& purity );
		virtual std::vector<Float_t> GetMulticlassTrainingEfficiency(std::vec
		tor<std::vector<Float_t> >& purity );
	virtual Double_t GetSignificance() const;	virtual Double_t GetSignificance() const;
	virtual Double_t GetROCIntegral(PDF pdfS=0, PDF pdfB=0) const;	virtual Double_t GetROCIntegral(PDF pdfS=0, PDF pdfB=0) const;
	virtual Double_t GetMaximumSignificance( Double_t SignalEvents, Doubl e_t BackgroundEvents,	virtual Double_t GetMaximumSignificance( Double_t SignalEvents, Doubl e_t BackgroundEvents,
	Double_t& optimal_significan ce_value ) const;	Double_t& optimal_significan ce_value ) const;
	virtual Double_t GetSeparation( TH1, TH1 ) const;	virtual Double_t GetSeparation( TH1, TH1 ) const;
	virtual Double_t GetSeparation( PDF* pdfS = 0, PDF* pdfB = 0 ) const;	virtual Double_t GetSeparation( PDF* pdfS = 0, PDF* pdfB = 0 ) const;


		virtual void GetRegressionDeviation(UInt_t tgtNum, Types::ETreeType t ype, Double_t& stddev,Double_t& stddev90Percent ) const;
	// ---------- public accessors -------------------------------------- ---------	// ---------- public accessors -------------------------------------- ---------

	// classifier naming (a lot of names ... aren't they ;-)	// classifier naming (a lot of names ... aren't they ;-)
	const TString& GetJobName () const { return fJobName; }	const TString& GetJobName () const { return fJobName; }
	const TString& GetMethodName () const { return fMethodName; }	const TString& GetMethodName () const { return fMethodName; }
	TString GetMethodTypeName() const { return Types::Instance() .GetMethodName(fMethodType); }	TString GetMethodTypeName() const { return Types::Instance() .GetMethodName(fMethodType); }
	Types::EMVA GetMethodType () const { return fMethodType; }	Types::EMVA GetMethodType () const { return fMethodType; }
	const char* GetName () const { return fMethodName.Data( ); }	const char* GetName () const { return fMethodName.Data( ); }
	const TString& GetTestvarName () const { return fTestvar; }	const TString& GetTestvarName () const { return fTestvar; }
	const TString GetProbaName () const { return fTestvar + "_Prob a"; }	const TString GetProbaName () const { return fTestvar + "_Prob a"; }

End of changes. 12 change blocks.
	13 lines changed or deleted	43 lines changed or added

	MethodBayesClassifier.h	MethodBayesClassifier.h

	// @(#)root/tmva $Id: MethodBayesClassifier.h 31458 2009-11-30 13:58:20Z st elzer $	// @(#)root/tmva $Id: MethodBayesClassifier.h 36966 2010-11-26 09:50:13Z ev t $
	// Author: Abhishek Narain	// Author: Abhishek Narain

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodBayesClassifier *	* Class : MethodBayesClassifier *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Bayesian Classifier *	* Bayesian Classifier *

	skipping to change at line 79	skipping to change at line 79
	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	// write weights to file	// write weights to file
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( istream& istr );	void ReadWeightsFromStream( istream& istr );
	void ReadWeightsFromXML ( void* /wghtnode/ ) {}	void ReadWeightsFromXML ( void* /wghtnode/ ) {}

	// calculate the MVA value	// calculate the MVA value

	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0 );

	void Init( void );	void Init( void );

	// ranking of input variables	// ranking of input variables
	const Ranking* CreateRanking() { return 0; }	const Ranking* CreateRanking() { return 0; }

	protected:	protected:

	// make ROOT-independent C++ class for classifier response (classifie r-specific implementation)	// make ROOT-independent C++ class for classifier response (classifie r-specific implementation)
	void MakeClassSpecific( std::ostream&, const TString& ) const;	void MakeClassSpecific( std::ostream&, const TString& ) const;

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

	MethodBoost.h	MethodBoost.h

	// @(#)root/tmva $Id: MethodBoost.h 35738 2010-09-26 09:17:57Z stelzer $	// @(#)root/tmva $Id: MethodBoost.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss,Or Cohen	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss,Or Cohen

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodCompositeBase *	* Class : MethodCompositeBase *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Virtual base class for all MVA method *	* Virtual base class for all MVA method *

	skipping to change at line 101	skipping to change at line 101
	// gives the monitoring historgram from the vector according to index of the	// gives the monitoring historgram from the vector according to index of the
	// histrogram added in the MonitorBoost function	// histrogram added in the MonitorBoost function
	TH1* GetMonitoringHist( Int_t histInd ) { return (*fMonitor Hist)[fDefaultHistNum+histInd]; }	TH1* GetMonitoringHist( Int_t histInd ) { return (*fMonitor Hist)[fDefaultHistNum+histInd]; }

	void AddMonitoringHist( TH1* hist ) { return fMonitorHi st->push_back(hist); }	void AddMonitoringHist( TH1* hist ) { return fMonitorHi st->push_back(hist); }

	Types::EBoostStage GetBoostStage() { return fBoostStage; }	Types::EBoostStage GetBoostStage() { return fBoostStage; }

	void CleanBoostOptions();	void CleanBoostOptions();


	Double_t GetMvaValue( Double_t* err );	Double_t GetMvaValue( Double_t* err=0, Double_t* errUpper = 0 );

	private :	private :
	// clean up	// clean up
	void ClearAll();	void ClearAll();

	// print fit results	// print fit results
	void PrintResults( const TString&, std::vector<Double_t>&, const Doub le_t ) const;	void PrintResults( const TString&, std::vector<Double_t>&, const Doub le_t ) const;

	// initializing mostly monitoring tools of the boost process	// initializing mostly monitoring tools of the boost process
	void Init();	void Init();

	skipping to change at line 127	skipping to change at line 127
	void ProcessOptions();	void ProcessOptions();

	MethodBoost* SetStage( Types::EBoostStage stage ) { fBoostStage = sta ge; return this; }	MethodBoost* SetStage( Types::EBoostStage stage ) { fBoostStage = sta ge; return this; }

	//training a single classifier	//training a single classifier
	void SingleTrain();	void SingleTrain();

	//calculating a boosting weight from the classifier, storing it in th e next one	//calculating a boosting weight from the classifier, storing it in th e next one
	void SingleBoost();	void SingleBoost();


		// calculate weight of single method
		void CalcMethodWeight();

		// return ROC integral on training/testing sample
		Double_t GetBoostROCIntegral(Bool_t, Types::ETreeType, Bool_t CalcOve
		rlapIntergral=kFALSE);

	//writing the monitoring histograms and tree to a file	//writing the monitoring histograms and tree to a file
	void WriteMonitoringHistosToFile( void ) const;	void WriteMonitoringHistosToFile( void ) const;

	// write evaluation histograms into target file	// write evaluation histograms into target file
	virtual void WriteEvaluationHistosToFile(Types::ETreeType treetype);	virtual void WriteEvaluationHistosToFile(Types::ETreeType treetype);

	// performs the MethodBase testing + testing of each boosted classifi er	// performs the MethodBase testing + testing of each boosted classifi er
	virtual void TestClassification();	virtual void TestClassification();

	//finding the MVA to cut between sig and bgd according to fMVACutPerc ,fMVACutType	//finding the MVA to cut between sig and bgd according to fMVACutPerc ,fMVACutType
	void FindMVACut();	void FindMVACut();

	//setting all the boost weights to 1	//setting all the boost weights to 1
	void ResetBoostWeights();	void ResetBoostWeights();

	//creating the vectors of histogram for monitoring MVA response of ea ch classifier	//creating the vectors of histogram for monitoring MVA response of ea ch classifier
	void CreateMVAHistorgrams();	void CreateMVAHistorgrams();


		// calculate MVA values of current trained method on training
		// sample
		void CalcMVAValues();

	//Number of times the classifier is boosted (set by the user)	//Number of times the classifier is boosted (set by the user)
	Int_t fBoostNum;	Int_t fBoostNum;
	// string specifying the boost type (AdaBoost / Bagging )	// string specifying the boost type (AdaBoost / Bagging )
	TString fBoostType;	TString fBoostType;

	// string specifying the boost type ( ByError,Average,LastMethod )	// string specifying the boost type ( ByError,Average,LastMethod )
	TString fMethodWeightType;	TString fMethodWeightType;

	//estimation of the level error of the classifier analysing the train dataset	//estimation of the level error of the classifier analysing the train dataset
	Double_t fMethodError;	Double_t fMethodError;

	skipping to change at line 167	skipping to change at line 177

	//the weight used to boost the next classifier	//the weight used to boost the next classifier
	Double_t fBoostWeight;	Double_t fBoostWeight;

	// min and max values for the classifier response	// min and max values for the classifier response
	TString fTransformString;	TString fTransformString;

	//ADA boost parameter, default is 1	//ADA boost parameter, default is 1
	Double_t fADABoostBeta;	Double_t fADABoostBeta;


		// seed for random number generator used for bagging
		UInt_t fRandomSeed;

	// details of the boosted classifier	// details of the boosted classifier
	TString fBoostedMethodName;	TString fBoostedMethodName;
	TString fBoostedMethodTitle;	TString fBoostedMethodTitle;
	TString fBoostedMethodOptions;	TString fBoostedMethodOptions;

	// histograms to monitor values during the boosting	// histograms to monitor values during the boosting
	std::vector<TH1> fMonitorHist;	std::vector<TH1> fMonitorHist;

	//whether to monitor the MVA response of every classifier using the	//whether to monitor the MVA response of every classifier using the
	Bool_t fMonitorBoostedMethod;	Bool_t fMonitorBoostedMethod;

	skipping to change at line 200	skipping to change at line 213

	// the stage of the boosting	// the stage of the boosting
	Types::EBoostStage fBoostStage;	Types::EBoostStage fBoostStage;

	//the number of histogram filled for every type of boosted classifier	//the number of histogram filled for every type of boosted classifier
	Int_t fDefaultHistNum;	Int_t fDefaultHistNum;

	//whether to recalculate the MVA cut at every boosting step	//whether to recalculate the MVA cut at every boosting step
	Bool_t fRecalculateMVACut;	Bool_t fRecalculateMVACut;


		// roc integral of last trained method (on training sample)
		Double_t fROC_training;

		// overlap integral of mva distributions for signal and
		// background (training sample)
		Double_t fOverlap_integral;

		// mva values for the last trained method (on training sample)
		std::vector<Float_t> *fMVAvalues;

	DataSetManager* fDataSetManager; // DSMTEST	DataSetManager* fDataSetManager; // DSMTEST
	friend class Factory; // DSMTEST	friend class Factory; // DSMTEST
	friend class Reader; // DSMTEST	friend class Reader; // DSMTEST

	protected:	protected:

	// get help message text	// get help message text
	void GetHelpMessage() const;	void GetHelpMessage() const;

	ClassDef(MethodBoost,0)	ClassDef(MethodBoost,0)

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

	MethodCFMlpANN_Utils.h	MethodCFMlpANN_Utils.h

	// @(#)root/tmva $Id: MethodCFMlpANN_Utils.h 35719 2010-09-24 17:32:57Z ste lzer $	// @(#)root/tmva $Id: MethodCFMlpANN_Utils.h 37181 2010-12-02 13:45:02Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodCFMlpANN_utils *	* Class : MethodCFMlpANN_utils *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Reference for the original FORTRAN version "mlpl3.F": *	* Reference for the original FORTRAN version "mlpl3.F": *
	* Authors : J. Proriol and contributions from ALEPH-Clermont-Fd *	* Authors : J. Proriol and contributions from ALEPH-Clermont-Fd *

	skipping to change at line 41	skipping to change at line 41
	* modification, are permitted according to the terms listed in LICENSE *	* modification, are permitted according to the terms listed in LICENSE *
	* (http://tmva.sourceforge.net/LICENSE) *	* (http://tmva.sourceforge.net/LICENSE) *
	************************************************************************ ******/	************************************************************************ ******/

	#ifndef ROOT_TMVA_MethodCFMlpANN_Utils	#ifndef ROOT_TMVA_MethodCFMlpANN_Utils
	#define ROOT_TMVA_MethodCFMlpANN_Utils	#define ROOT_TMVA_MethodCFMlpANN_Utils

	#ifndef ROOT_TMVA_MethodCFMlpANN_def	#ifndef ROOT_TMVA_MethodCFMlpANN_def
	#include "TMVA/MethodCFMlpANN_def.h"	#include "TMVA/MethodCFMlpANN_def.h"
	#endif	#endif

		#ifndef ROOT_TMVA_MsgLogger
		#include "TMVA/MsgLogger.h"
		#endif

	#ifndef ROOT_Rtypes	#ifndef ROOT_Rtypes
	#include "Rtypes.h"	#include "Rtypes.h"
	#endif	#endif

	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// //	// //
	// MethodCFMlpANN_Utils //	// MethodCFMlpANN_Utils //
	// //	// //
	// Implementation of Clermond-Ferrand artificial neural network //	// Implementation of Clermond-Ferrand artificial neural network //

	skipping to change at line 151	skipping to change at line 154
	void Create( Int_t nevt, Int_t nvar ) {	void Create( Int_t nevt, Int_t nvar ) {
	fNevt = nevt+1; fNvar = nvar+1; // fortran array style 1...N	fNevt = nevt+1; fNvar = nvar+1; // fortran array style 1...N
	fxx = new Double_t*[fNevt];	fxx = new Double_t*[fNevt];
	for (Int_t i=0; i<fNevt; i++) fxx[i] = new Double_t[fNvar];	for (Int_t i=0; i<fNevt; i++) fxx[i] = new Double_t[fNvar];
	}	}
	Double_t operator=( Double_t val ) { return val; }	Double_t operator=( Double_t val ) { return val; }
	Double_t &operator()( Int_t ievt, Int_t ivar ) const {	Double_t &operator()( Int_t ievt, Int_t ivar ) const {
	if (0 != fxx && ievt < fNevt && ivar < fNvar) return fxx[ievt][ ivar];	if (0 != fxx && ievt < fNevt && ivar < fNvar) return fxx[ievt][ ivar];
	else {	else {
	printf( "* ERROR in varn3_(): fxx is zero pointer ==> abor t *\n") ;	printf( "* ERROR in varn3_(): fxx is zero pointer ==> abor t *\n") ;

	// exit(1);	std::exit(1);
	return fxx[0][0];	return fxx[0][0];
	}	}
	}	}
	void Delete( void ) {	void Delete( void ) {
	if (0 != fxx) for (Int_t i=0; i<fNevt; i++) if (0 != fxx[i]) de lete [] fxx[i];	if (0 != fxx) for (Int_t i=0; i<fNevt; i++) if (0 != fxx[i]) de lete [] fxx[i];
	delete[] fxx;	delete[] fxx;
	fxx=0;	fxx=0;
	}	}

	Double_t** fxx;	Double_t** fxx;

	skipping to change at line 194	skipping to change at line 197
	Double_t delww[max_nLayers_*max_nNodes_];	Double_t delww[max_nLayers_*max_nNodes_];
	Int_t idde;	Int_t idde;
	} fDel_1;	} fDel_1;

	// flags and stuff (don't ask me...)	// flags and stuff (don't ask me...)
	struct {	struct {
	Double_t ancout, tolcou;	Double_t ancout, tolcou;
	Int_t ieps;	Int_t ieps;
	} fCost_1;	} fCost_1;


		void SetLogger(MsgLogger *l) { fLogger = l; }

		private:
		MsgLogger * fLogger;
		MsgLogger& ULog() { if (fLogger) return fLogger; return (fLogger =
		new MsgLogger("CFMLP_Utils")); } // avoiding control reaches end of non-vo
		id function warning

		public:

	ClassDef(MethodCFMlpANN_Utils,0) // Implementation of Clermond-Ferra nd artificial neural network	ClassDef(MethodCFMlpANN_Utils,0) // Implementation of Clermond-Ferra nd artificial neural network
	};	};

	} // namespace TMVA	} // namespace TMVA

	#endif	#endif

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

	MethodCategory.h	MethodCategory.h

	// @(#)root/tmva $Id: MethodCategory.h 33928 2010-06-15 16:19:31Z stelzer $	// @(#)root/tmva $Id: MethodCategory.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss,Or Cohen	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss,Or Cohen

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodCompositeBase *	* Class : MethodCompositeBase *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Virtual base class for all MVA method *	* Virtual base class for all MVA method *

	skipping to change at line 94	skipping to change at line 94
	// saves the name and options string of the boosted classifier	// saves the name and options string of the boosted classifier
	TMVA::IMethod* AddMethod(const TCut&,	TMVA::IMethod* AddMethod(const TCut&,
	const TString& theVariables,	const TString& theVariables,
	Types::EMVA theMethod,	Types::EMVA theMethod,
	const TString& theTitle,	const TString& theTitle,
	const TString& theOptions);	const TString& theOptions);

	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;
	void ReadWeightsFromXML( void* wghtnode );	void ReadWeightsFromXML( void* wghtnode );


	Double_t GetMvaValue( Double_t* err );	Double_t GetMvaValue( Double_t* err=0, Double_t* errUpper = 0 );

	virtual void MakeClass( const TString& = TString("") ) const {};	virtual void MakeClass( const TString& = TString("") ) const {};

	private :	private :

	// initializing mostly monitoring tools of the category process	// initializing mostly monitoring tools of the category process
	void Init();	void Init();

	// the option handling methods	// the option handling methods
	void DeclareOptions();	void DeclareOptions();

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

	MethodCommittee.h	MethodCommittee.h

	// @(#)root/tmva $Id: MethodCommittee.h 31458 2009-11-30 13:58:20Z stelzer $	// @(#)root/tmva $Id: MethodCommittee.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodCommittee *	* Class : MethodCommittee *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Boosting *	* Boosting *

	skipping to change at line 94	skipping to change at line 94
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( istream& istr );	void ReadWeightsFromStream( istream& istr );
	void ReadWeightsFromXML ( void* /wghtnode/ ) {}	void ReadWeightsFromXML ( void* /wghtnode/ ) {}

	// write method specific histos to target file	// write method specific histos to target file
	void WriteMonitoringHistosToFile( void ) const;	void WriteMonitoringHistosToFile( void ) const;

	// calculate the MVA value	// calculate the MVA value

	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0 );

	// apply the boost algorithm to a member in the committee	// apply the boost algorithm to a member in the committee
	Double_t Boost( TMVA::MethodBase*, UInt_t imember );	Double_t Boost( TMVA::MethodBase*, UInt_t imember );

	// ranking of input variables	// ranking of input variables
	const Ranking* CreateRanking();	const Ranking* CreateRanking();

	// the option handling methods	// the option handling methods
	void DeclareOptions();	void DeclareOptions();
	void ProcessOptions();	void ProcessOptions();

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

	MethodCompositeBase.h	MethodCompositeBase.h

	// @(#)root/tmva $Id: MethodCompositeBase.h 31458 2009-11-30 13:58:20Z stel zer $	// @(#)root/tmva $Id: MethodCompositeBase.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss,Or Cohen	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss,Or Cohen

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodCompositeBase *	* Class : MethodCompositeBase *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Virtual base class for all MVA method *	* Virtual base class for all MVA method *

	skipping to change at line 74	skipping to change at line 74
	const TString& weightFile,	const TString& weightFile,
	TDirectory* theBaseDir = 0 );	TDirectory* theBaseDir = 0 );

	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	// write weights to file	// write weights to file
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;
	void ReadWeightsFromXML( void* wghtnode );	void ReadWeightsFromXML( void* wghtnode );

	// calculate the MVA value combining all classifiers according to thi er fMethodWeight	// calculate the MVA value combining all classifiers according to thi er fMethodWeight

	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0 );

		using MethodBase::GetMvaValue;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( istream& istr );	void ReadWeightsFromStream( istream& istr );

	// performs classifier training	// performs classifier training
	virtual void Train() = 0;	virtual void Train() = 0;

	// create ranking	// create ranking
	virtual const Ranking* CreateRanking() = 0;	virtual const Ranking* CreateRanking() = 0;


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

	MethodFDA.h	MethodFDA.h

	// @(#)root/tmva $Id: MethodFDA.h 33928 2010-06-15 16:19:31Z stelzer $	// @(#)root/tmva $Id: MethodFDA.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Andreas Hoecker, Peter Speckmayer	// Author: Andreas Hoecker, Peter Speckmayer

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodFDA *	* Class : MethodFDA *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Function discriminant analysis (FDA). This simple classifier *	* Function discriminant analysis (FDA). This simple classifier *

	skipping to change at line 93	skipping to change at line 93
	void Train( void );	void Train( void );

	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	void AddWeightsXMLTo ( void* parent ) const;	void AddWeightsXMLTo ( void* parent ) const;

	void ReadWeightsFromStream( std::istream & i );	void ReadWeightsFromStream( std::istream & i );
	void ReadWeightsFromXML ( void* wghtnode );	void ReadWeightsFromXML ( void* wghtnode );

	// calculate the MVA value	// calculate the MVA value

	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0 );

	virtual const std::vector<Float_t>& GetRegressionValues();	virtual const std::vector<Float_t>& GetRegressionValues();
	virtual const std::vector<Float_t>& GetMulticlassValues();	virtual const std::vector<Float_t>& GetMulticlassValues();

	void Init( void );	void Init( void );

	// ranking of input variables	// ranking of input variables
	const Ranking* CreateRanking() { return 0; }	const Ranking* CreateRanking() { return 0; }

	Double_t EstimatorFunction( std::vector<Double_t>& );	Double_t EstimatorFunction( std::vector<Double_t>& );

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

	MethodFisher.h	MethodFisher.h

	// @(#)root/tmva $Id: MethodFisher.h 31458 2009-11-30 13:58:20Z stelzer $	// @(#)root/tmva $Id: MethodFisher.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Andreas Hoecker, Xavier Prudent, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Xavier Prudent, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodFisher *	* Class : MethodFisher *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Analysis of Fisher discriminant (Fisher or Mahalanobis approach) *	* Analysis of Fisher discriminant (Fisher or Mahalanobis approach) *

	skipping to change at line 89	skipping to change at line 89
	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	// write weights to stream	// write weights to stream
	void AddWeightsXMLTo ( void* parent ) const;	void AddWeightsXMLTo ( void* parent ) const;

	// read weights from stream	// read weights from stream
	void ReadWeightsFromStream( std::istream & i );	void ReadWeightsFromStream( std::istream & i );
	void ReadWeightsFromXML ( void* wghtnode );	void ReadWeightsFromXML ( void* wghtnode );

	// calculate the MVA value	// calculate the MVA value

	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0 );

	enum EFisherMethod { kFisher, kMahalanobis };	enum EFisherMethod { kFisher, kMahalanobis };
	EFisherMethod GetFisherMethod( void ) { return fFisherMethod; }	EFisherMethod GetFisherMethod( void ) { return fFisherMethod; }

	// ranking of input variables	// ranking of input variables
	const Ranking* CreateRanking();	const Ranking* CreateRanking();

	protected:	protected:

	// make ROOT-independent C++ class for classifier response (classifie r-specific implementation)	// make ROOT-independent C++ class for classifier response (classifie r-specific implementation)

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

	MethodHMatrix.h	MethodHMatrix.h

	// @(#)root/tmva $Id: MethodHMatrix.h 31458 2009-11-30 13:58:20Z stelzer $	// @(#)root/tmva $Id: MethodHMatrix.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodHMatrix *	* Class : MethodHMatrix *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* H-Matrix method, which is implemented as a simple comparison of *	* H-Matrix method, which is implemented as a simple comparison of *

	skipping to change at line 92	skipping to change at line 92

	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	// write weights to file	// write weights to file
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( istream& istr );	void ReadWeightsFromStream( istream& istr );
	void ReadWeightsFromXML( void* wghtnode );	void ReadWeightsFromXML( void* wghtnode );
	// calculate the MVA value	// calculate the MVA value

	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0 );

	// ranking of input variables	// ranking of input variables
	const Ranking* CreateRanking() { return 0; }	const Ranking* CreateRanking() { return 0; }

	protected:	protected:

	// make ROOT-independent C++ class for classifier response (classifie r-specific implementation)	// make ROOT-independent C++ class for classifier response (classifie r-specific implementation)
	void MakeClassSpecific( std::ostream&, const TString& ) const;	void MakeClassSpecific( std::ostream&, const TString& ) const;

	// get help message text	// get help message text

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

	MethodKNN.h	MethodKNN.h

	// @(#)root/tmva $Id: MethodKNN.h 31458 2009-11-30 13:58:20Z stelzer $	// @(#)root/tmva $Id: MethodKNN.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Rustem Ospanov	// Author: Rustem Ospanov

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodKNN *	* Class : MethodKNN *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Analysis of k-nearest neighbor *	* Analysis of k-nearest neighbor *

	skipping to change at line 80	skipping to change at line 80
	MethodKNN(DataSetInfo& theData,	MethodKNN(DataSetInfo& theData,
	const TString& theWeightFile,	const TString& theWeightFile,
	TDirectory* theTargetDir = NULL);	TDirectory* theTargetDir = NULL);

	virtual ~MethodKNN( void );	virtual ~MethodKNN( void );

	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );

	void Train( void );	void Train( void );


	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0 );
	const std::vector<Float_t>& GetRegressionValues();	const std::vector<Float_t>& GetRegressionValues();

	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	void WriteWeightsToStream(TFile& rf) const;	void WriteWeightsToStream(TFile& rf) const;
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;
	void ReadWeightsFromXML( void* wghtnode );	void ReadWeightsFromXML( void* wghtnode );

	void ReadWeightsFromStream(std::istream& istr);	void ReadWeightsFromStream(std::istream& istr);
	void ReadWeightsFromStream(TFile &rf);	void ReadWeightsFromStream(TFile &rf);

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

	MethodLD.h	MethodLD.h

	skipping to change at line 78	skipping to change at line 78

	// destructor	// destructor
	virtual ~MethodLD( void );	virtual ~MethodLD( void );

	Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t numberClass es, UInt_t numberTargets );	Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t numberClass es, UInt_t numberTargets );

	// training method	// training method
	void Train( void );	void Train( void );

	// calculate the MVA value	// calculate the MVA value

	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0 );

	// calculate the Regression value	// calculate the Regression value
	virtual const std::vector<Float_t>& GetRegressionValues();	virtual const std::vector<Float_t>& GetRegressionValues();

	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	void AddWeightsXMLTo ( void* parent ) const;	void AddWeightsXMLTo ( void* parent ) const;

	void ReadWeightsFromStream( std::istream & i );	void ReadWeightsFromStream( std::istream & i );
	void ReadWeightsFromXML ( void* wghtnode );	void ReadWeightsFromXML ( void* wghtnode );

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

	MethodLikelihood.h	MethodLikelihood.h

	// @(#)root/tmva $Id: MethodLikelihood.h 31458 2009-11-30 13:58:20Z stelzer $	// @(#)root/tmva $Id: MethodLikelihood.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodLikelihood *	* Class : MethodLikelihood *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Likelihood analysis ("non-parametric approach") *	* Likelihood analysis ("non-parametric approach") *

	skipping to change at line 91	skipping to change at line 91
	// write weights to file	// write weights to file
	void WriteWeightsToStream( TFile& rf ) const;	void WriteWeightsToStream( TFile& rf ) const;
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( istream& istr );	void ReadWeightsFromStream( istream& istr );
	void ReadWeightsFromStream( TFile& istr );	void ReadWeightsFromStream( TFile& istr );
	void ReadWeightsFromXML( void* wghtnode );	void ReadWeightsFromXML( void* wghtnode );
	// calculate the MVA value	// calculate the MVA value
	// the argument is used for internal ranking tests	// the argument is used for internal ranking tests

	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0 );

	// write method specific histos to target file	// write method specific histos to target file
	void WriteMonitoringHistosToFile() const;	void WriteMonitoringHistosToFile() const;

	// ranking of input variables	// ranking of input variables
	const Ranking* CreateRanking();	const Ranking* CreateRanking();

	virtual void WriteOptionsToStream ( ostream& o, const TString& prefix ) const;	virtual void WriteOptionsToStream ( ostream& o, const TString& prefix ) const;

	protected:	protected:

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

	MethodMLP.h	MethodMLP.h

	// @(#)root/tmva $Id: MethodMLP.h 33928 2010-06-15 16:19:31Z stelzer $	// @(#)root/tmva $Id: MethodMLP.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Andreas Hoecker, Peter Speckmayer, Matt Jachowski	// Author: Andreas Hoecker, Peter Speckmayer, Matt Jachowski

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodMLP *	* Class : MethodMLP *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* ANN Multilayer Perceptron class for the discrimination of signal *	* ANN Multilayer Perceptron class for the discrimination of signal *

	skipping to change at line 114	skipping to change at line 114

	void Train() { Train(NumCycles()); }	void Train() { Train(NumCycles()); }

	// for GA	// for GA
	Double_t ComputeEstimator ( std::vector<Double_t>& parameters );	Double_t ComputeEstimator ( std::vector<Double_t>& parameters );
	Double_t EstimatorFunction( std::vector<Double_t>& parameters );	Double_t EstimatorFunction( std::vector<Double_t>& parameters );

	enum ETrainingMethod { kBP=0, kBFGS, kGA };	enum ETrainingMethod { kBP=0, kBFGS, kGA };
	enum EBPTrainingMode { kSequential=0, kBatch };	enum EBPTrainingMode { kSequential=0, kBatch };


	Double_t GetMvaValues( Double_t& errUpper, Double_t& errLower );	bool HasInverseHessian() { return fCalculateErrors; }
	//zjh	Double_t GetMvaValueAsymError( Double_t* errUpper, Double_t* errLower
		);

	protected:	protected:

	// make ROOT-independent C++ class for classifier response (classifie r-specific implementation)	// make ROOT-independent C++ class for classifier response (classifie r-specific implementation)
	void MakeClassSpecific( std::ostream&, const TString& ) const;	void MakeClassSpecific( std::ostream&, const TString& ) const;

	// get help message text	// get help message text
	void GetHelpMessage() const;	void GetHelpMessage() const;

	private:	private:

	skipping to change at line 182	skipping to change at line 183
	#ifdef MethodMLP_UseMinuit__	#ifdef MethodMLP_UseMinuit__
	// minuit functions -- commented out because they rely on a static po inter	// minuit functions -- commented out because they rely on a static po inter
	void MinuitMinimize();	void MinuitMinimize();
	static MethodMLP* GetThisPtr();	static MethodMLP* GetThisPtr();
	static void IFCN( Int_t& npars, Double_t* grad, Double_t &f, Double_t * fitPars, Int_t ifl );	static void IFCN( Int_t& npars, Double_t* grad, Double_t &f, Double_t * fitPars, Int_t ifl );
	void FCN( Int_t& npars, Double_t* grad, Double_t &f, Double_t* fitPar s, Int_t ifl );	void FCN( Int_t& npars, Double_t* grad, Double_t &f, Double_t* fitPar s, Int_t ifl );
	#endif	#endif

	// general	// general
	bool fUseRegulator; // zjh	bool fUseRegulator; // zjh

		bool fCalculateErrors; // compute inverse hessian matrix at the end of the training
	Double_t fPrior; // zjh	Double_t fPrior; // zjh
	std::vector<Double_t> fPriorDev; // zjh	std::vector<Double_t> fPriorDev; // zjh
	void GetApproxInvHessian ( TMatrixD& InvHessian, bool r egulate=true ); //rank-1 approximation, neglect 2nd derivatives. //zjh	void GetApproxInvHessian ( TMatrixD& InvHessian, bool r egulate=true ); //rank-1 approximation, neglect 2nd derivatives. //zjh
	void UpdateRegulators(); // zjh	void UpdateRegulators(); // zjh
	void UpdatePriors(); // zjh	void UpdatePriors(); // zjh
	Int_t fUpdateLimit; // zjh	Int_t fUpdateLimit; // zjh

	ETrainingMethod fTrainingMethod; // method of training, BP or GA	ETrainingMethod fTrainingMethod; // method of training, BP or GA
	TString fTrainMethodS; // training method option param	TString fTrainMethodS; // training method option param


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

	MethodPDEFoam.h	MethodPDEFoam.h

	// @(#)root/tmva $Id: MethodPDEFoam.h 31458 2009-11-30 13:58:20Z stelzer $	// @(#)root/tmva $Id: MethodPDEFoam.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Tancredi Carli, Dominik Dannheim, Alexander Voigt	// Author: Tancredi Carli, Dominik Dannheim, Alexander Voigt

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate Data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate Data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodPDEFoam *	* Class : MethodPDEFoam *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* The PDEFoam method is an extension of the PDERS method, which divid es *	* The PDEFoam method is an extension of the PDERS method, which divid es *
	* the multi-dimensional phase space in a finite number of hyper-recta ngles *	* the multi-dimensional phase space in a finite number of hyper-recta ngles *
	* (cells) of constant event density. This "foam" of cells is filled w ith *	* (cells) of constant event density. This "foam" of cells is filled w ith *
	* averaged probability-density information sampled from a training ev ent *	* averaged probability-density information sampled from a training ev ent *

	* sample.	* sample. *
	* *	* *
	* Authors (alphabetical): *	* Authors (alphabetical): *
	* Tancredi Carli - CERN, Switzerland *	* Tancredi Carli - CERN, Switzerland *
	* Dominik Dannheim - CERN, Switzerland *	* Dominik Dannheim - CERN, Switzerland *
	* Peter Speckmayer <peter.speckmayer@cern.ch> - CERN, Switzerland *	* Peter Speckmayer <peter.speckmayer@cern.ch> - CERN, Switzerland *
	* Alexander Voigt - CERN, Switzerland *	* Alexander Voigt - CERN, Switzerland *
	* *	* *
	* Original author of the TFoam implementation: *	* Original author of the TFoam implementation: *
	* S. Jadach - Institute of Nuclear Physics, Cracow, Poland *	* S. Jadach - Institute of Nuclear Physics, Cracow, Poland *
	* *	* *

	skipping to change at line 74	skipping to change at line 74
	#endif	#endif

	#ifndef ROOT_TMVA_MethodBase	#ifndef ROOT_TMVA_MethodBase
	#include "TMVA/MethodBase.h"	#include "TMVA/MethodBase.h"
	#endif	#endif

	#ifndef ROOT_TMVA_PDEFoam	#ifndef ROOT_TMVA_PDEFoam
	#include "TMVA/PDEFoam.h"	#include "TMVA/PDEFoam.h"
	#endif	#endif


	#define FOAM_NUMBER 2

	namespace TMVA {	namespace TMVA {

	class MethodPDEFoam : public MethodBase {	class MethodPDEFoam : public MethodBase {

	public:	public:

	MethodPDEFoam( const TString& jobName,	MethodPDEFoam( const TString& jobName,
	const TString& methodTitle,	const TString& methodTitle,
	DataSetInfo& dsi,	DataSetInfo& dsi,
	const TString& theOption = "PDEFoam",	const TString& theOption = "PDEFoam",

	skipping to change at line 117	skipping to change at line 115

	// read weights from stream	// read weights from stream
	void ReadWeightsFromStream( std::istream & i );	void ReadWeightsFromStream( std::istream & i );
	void ReadWeightsFromXML ( void* wghtnode );	void ReadWeightsFromXML ( void* wghtnode );

	// write/read pure foams to/from file	// write/read pure foams to/from file
	void WriteFoamsToFile() const;	void WriteFoamsToFile() const;
	void ReadFoamsFromFile();	void ReadFoamsFromFile();

	// calculate the MVA value	// calculate the MVA value

	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0 );

	// regression procedure	// regression procedure
	virtual const std::vector<Float_t>& GetRegressionValues();	virtual const std::vector<Float_t>& GetRegressionValues();

	// ranking of input variables	// ranking of input variables
	const Ranking* CreateRanking() { return 0; }	const Ranking* CreateRanking() { return 0; }


	// possible kernels (option)	// helper functions to convert enum types to UInt_t and back
	EKernel GetKernel( void ) { return fKernel; }	EKernel GetKernel( void ) { return fKernel; }

	UInt_t KernelToUInt(EKernel ker) const {	UInt_t KernelToUInt(EKernel ker) const { return UInt_t(ker); }
	if (ker == kNone)	EKernel UIntToKernel(UInt_t iker);
	return 0;	UInt_t TargetSelectionToUInt(ETargetSelection ts) const { return UInt
	else if (ker == kGaus)	_t(ts); }
	return 1;	ETargetSelection UIntToTargetSelection(UInt_t its);
	else if (ker == kLinN)
	return 2;
	else {
	Log() << kFATAL << "Error: unknown kernel!" << Endl;
	return 0;
	}
	}
	EKernel UIntToKernel(UInt_t iker){
	if (iker == 0)
	return kNone;
	else if (iker == 1)
	return kGaus;
	else if (iker == 2)
	return kLinN;
	else {
	Log() << kFATAL << "Error: unknown kernel number: " << iker <<
	Endl;
	return kNone;
	}
	}
	UInt_t TargetSelectionToUInt(ETargetSelection ts) const {
	if (ts == kMean)
	return 0;
	else if (ts == kMpv)
	return 1;
	else {
	std::cout << "Error: unknown method TargetSelection!" << std::e
	ndl;
	return 0;
	}
	}
	ETargetSelection UIntToTargetSelection(UInt_t its){
	if (its == 0)
	return kMean;
	else if (its == 1)
	return kMpv;
	else {
	std::cout << "Error: unknown method TargetSelection: " << its <
	< std::endl;
	return kMean;
	}
	}

	protected:	protected:

	// make ROOT-independent C++ class for classifier response (classifie r-specific implementation)	// make ROOT-independent C++ class for classifier response (classifie r-specific implementation)
	void MakeClassSpecific( std::ostream&, const TString& ) const;	void MakeClassSpecific( std::ostream&, const TString& ) const;

	// get help message text	// get help message text
	void GetHelpMessage() const;	void GetHelpMessage() const;

	// calculate Xmin and Xmax for Foam	// calculate Xmin and Xmax for Foam

	skipping to change at line 196	skipping to change at line 154
	// Set foam options	// Set foam options
	void InitFoam(TMVA::PDEFoam*, EFoamType);	void InitFoam(TMVA::PDEFoam*, EFoamType);

	// fill variable names into foam	// fill variable names into foam
	void FillVariableNamesToFoam() const;	void FillVariableNamesToFoam() const;

	private:	private:

	// the option handling methods	// the option handling methods
	void DeclareOptions();	void DeclareOptions();

		void DeclareCompatibilityOptions();
	void ProcessOptions();	void ProcessOptions();

	// nice output	// nice output
	void PrintCoefficients( void );	void PrintCoefficients( void );


		// Square function (fastest implementation)
		template<typename T> T Sqr(T x) const { return x*x; }

	// options to be used	// options to be used
	Bool_t fSigBgSeparated; // Separate Sig and Bg, or not	Bool_t fSigBgSeparated; // Separate Sig and Bg, or not
	Double_t fFrac; // Fraction used for calc of Xmin, Xm ax	Double_t fFrac; // Fraction used for calc of Xmin, Xm ax
	Double_t fDiscrErrCut; // cut on discrimant error	Double_t fDiscrErrCut; // cut on discrimant error

	Int_t fVolFrac; // inverse volume fraction (used for density calculation during buildup)	Float_t fVolFrac; // inverse volume fraction (used for density calculation during buildup)
	Float_t fVolFracInv; // volume fraction (used for density calculation during buildup)	Float_t fVolFracInv; // volume fraction (used for density calculation during buildup)
	Int_t fnCells; // Number of Cells (1000)	Int_t fnCells; // Number of Cells (1000)
	Int_t fnActiveCells; // Number of active cells	Int_t fnActiveCells; // Number of active cells
	Int_t fnSampl; // Number of MC events per cell in bu ild-up (1000)	Int_t fnSampl; // Number of MC events per cell in bu ild-up (1000)
	Int_t fnBin; // Number of bins in build-up (100)	Int_t fnBin; // Number of bins in build-up (100)
	Int_t fEvPerBin; // Maximum events (equiv.) per bin in buid-up (1000)	Int_t fEvPerBin; // Maximum events (equiv.) per bin in buid-up (1000)

	Float_t fNSigBgRatio; // ratio of number of signal events / bg events (training)

	Bool_t fCompress; // compress foam output file	Bool_t fCompress; // compress foam output file
	Bool_t fMultiTargetRegression; // do regression on multible ta rgets	Bool_t fMultiTargetRegression; // do regression on multible ta rgets
	UInt_t fNmin; // minimal number of events in cell n ecessary to split cell"	UInt_t fNmin; // minimal number of events in cell n ecessary to split cell"

	Bool_t fCutNmin; // Grabbing cell with maximal RMS to	Bool_t fCutNmin; // Keep for bw compatibility: Grabbin
	split next (TFoam default)	g cell with maximal RMS to split next (TFoam default)
	Double_t fRMSmin; // minimal number of events in cell n	UInt_t fMaxDepth; // maximum depth of cell tree
	ecessary to split cell"
	Bool_t fCutRMSmin; // Grabbing cell with maximal RMS to
	split next (TFoam default)

	TString fKernelStr; // Kernel for GetMvaValue() (option s tring)	TString fKernelStr; // Kernel for GetMvaValue() (option s tring)
	EKernel fKernel; // Kernel for GetMvaValue()	EKernel fKernel; // Kernel for GetMvaValue()
	TString fTargetSelectionStr; // method of selecting the target (only mulit target regr.)	TString fTargetSelectionStr; // method of selecting the target (only mulit target regr.)
	ETargetSelection fTargetSelection; // method of selecting the target (only mulit target regr.)	ETargetSelection fTargetSelection; // method of selecting the target (only mulit target regr.)

		Bool_t fFillFoamWithOrigWeights; // fill the foam with boost w
		eights
		Bool_t fUseYesNoCell; // return -1 or 1 for bg or signal li
		ke event
		TString fDTLogic; // use DT algorithm to split cells
		EDTSeparation fDTSeparation; // enum which specifies the separatio
		n to use for the DT logic
		Bool_t fPeekMax; // peek up cell with max. driver inte
		gral for split


	std::vector<Double_t> Xmin, Xmax; // range for histograms and foams	std::vector<Double_t> fXmin, fXmax; // range for histograms and foams

	// foams and densities	// foams and densities

	PDEFoam* foam[FOAM_NUMBER]; // foam[0]=signal, if Sig and BG are Sepe	// foam[0]=signal, if Sig and BG are Seperated; else foam[0]=signal/b
	rated; else foam[0]=signal/bg	g
	// foam[1]=background, if Sig and BG are	// foam[1]=background, if Sig and BG are Seperated; else it is not us
	Seperated; else it is not used	ed
		std::vector<PDEFoam*> fFoam;

	// default initialisation called by all constructors	// default initialisation called by all constructors
	void Init( void );	void Init( void );

	ClassDef(MethodPDEFoam,0) // Analysis of PDEFoam discriminant (PDEFoa m or Mahalanobis approach)	ClassDef(MethodPDEFoam,0) // Analysis of PDEFoam discriminant (PDEFoa m or Mahalanobis approach)
	};	};

	} // namespace TMVA	} // namespace TMVA

	#endif // MethodPDEFoam_H	#endif // MethodPDEFoam_H

End of changes. 14 change blocks.
	66 lines changed or deleted	32 lines changed or added

	MethodPDERS.h	MethodPDERS.h

	// @(#)root/tmva $Id: MethodPDERS.h 33928 2010-06-15 16:19:31Z stelzer $	// @(#)root/tmva $Id: MethodPDERS.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Andreas Hoecker, Yair Mahalalel, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Yair Mahalalel, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodPDERS *	* Class : MethodPDERS *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Multidimensional Likelihood using the "Probability density estimato r *	* Multidimensional Likelihood using the "Probability density estimato r *

	skipping to change at line 98	skipping to change at line 98
	// write weights to file	// write weights to file
	void WriteWeightsToStream( TFile& rf ) const;	void WriteWeightsToStream( TFile& rf ) const;
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( istream& istr );	void ReadWeightsFromStream( istream& istr );
	void ReadWeightsFromStream( TFile& istr );	void ReadWeightsFromStream( TFile& istr );
	void ReadWeightsFromXML( void* wghtnode );	void ReadWeightsFromXML( void* wghtnode );

	// calculate the MVA value	// calculate the MVA value

	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0 );

	// calculate the MVA value	// calculate the MVA value
	const std::vector<Float_t>& GetRegressionValues();	const std::vector<Float_t>& GetRegressionValues();
	public:	public:

	// for root finder	// for root finder
	static Double_t IGetVolumeContentForRoot( Double_t );	static Double_t IGetVolumeContentForRoot( Double_t );
	Double_t GetVolumeContentForRoot( Double_t );	Double_t GetVolumeContentForRoot( Double_t );

	// static pointer to this object	// static pointer to this object

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

	MethodRuleFit.h	MethodRuleFit.h

	// @(#)root/tmva $Id: MethodRuleFit.h 31458 2009-11-30 13:58:20Z stelzer $	// @(#)root/tmva $Id: MethodRuleFit.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Fredrik Tegenfeldt	// Author: Fredrik Tegenfeldt

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodRuleFit *	* Class : MethodRuleFit *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Friedman's RuleFit method *	* Friedman's RuleFit method *

	skipping to change at line 88	skipping to change at line 88
	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	// write weights to file	// write weights to file
	void AddWeightsXMLTo ( void* parent ) const;	void AddWeightsXMLTo ( void* parent ) const;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( istream& istr );	void ReadWeightsFromStream( istream& istr );
	void ReadWeightsFromXML ( void* wghtnode );	void ReadWeightsFromXML ( void* wghtnode );

	// calculate the MVA value	// calculate the MVA value

	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0 );

	// write method specific histos to target file	// write method specific histos to target file
	void WriteMonitoringHistosToFile( void ) const;	void WriteMonitoringHistosToFile( void ) const;

	// ranking of input variables	// ranking of input variables
	const Ranking* CreateRanking();	const Ranking* CreateRanking();

	Bool_t UseBoost() const { return fUseBoost; }	Bool_t UseBoost() const { return fUseBoost; }

	// accessors	// accessors

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

	MethodSVM.h	MethodSVM.h

	// @(#)root/tmva $Id: MethodSVM.h 31458 2009-11-30 13:58:20Z stelzer $	// @(#)root/tmva $Id: MethodSVM.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Marcin Wolter, Andrzej Zemla	// Author: Marcin Wolter, Andrzej Zemla

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodSVM *	* Class : MethodSVM *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Support Vector Machine *	* Support Vector Machine *

	skipping to change at line 92	skipping to change at line 92
	// write weights to file	// write weights to file
	void WriteWeightsToStream( TFile& fout ) const;	void WriteWeightsToStream( TFile& fout ) const;
	void AddWeightsXMLTo ( void* parent ) const;	void AddWeightsXMLTo ( void* parent ) const;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( std::istream& istr );	void ReadWeightsFromStream( std::istream& istr );
	void ReadWeightsFromStream( TFile& fFin );	void ReadWeightsFromStream( TFile& fFin );
	void ReadWeightsFromXML ( void* wghtnode );	void ReadWeightsFromXML ( void* wghtnode );
	// calculate the MVA value	// calculate the MVA value


	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0 );
	const std::vector<Float_t>& GetRegressionValues();	const std::vector<Float_t>& GetRegressionValues();

	void Init( void );	void Init( void );

	// ranking of input variables	// ranking of input variables
	const Ranking* CreateRanking() { return 0; }	const Ranking* CreateRanking() { return 0; }

	protected:	protected:

	// make ROOT-independent C++ class for classifier response (classifie r-specific implementation)	// make ROOT-independent C++ class for classifier response (classifie r-specific implementation)

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

	MethodTMlpANN.h	MethodTMlpANN.h

	// @(#)root/tmva $Id: MethodTMlpANN.h 31458 2009-11-30 13:58:20Z stelzer $	// @(#)root/tmva $Id: MethodTMlpANN.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodTMlpANN *	* Class : MethodTMlpANN *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Implementation of interface for Root-integrated artificial neural *	* Implementation of interface for Root-integrated artificial neural *

	skipping to change at line 85	skipping to change at line 85
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( istream& istr );	void ReadWeightsFromStream( istream& istr );
	void ReadWeightsFromXML(void* wghtnode);	void ReadWeightsFromXML(void* wghtnode);

	// calculate the MVA value ...	// calculate the MVA value ...
	// - here it is just a dummy, as it is done in the overwritten	// - here it is just a dummy, as it is done in the overwritten
	// - PrepareEvaluationtree... ugly but necessary due to the strucure	// - PrepareEvaluationtree... ugly but necessary due to the strucure
	// of TMultiLayerPercepton in ROOT grr... :-(	// of TMultiLayerPercepton in ROOT grr... :-(

	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0 );

	void SetHiddenLayer(TString hiddenlayer = "" ) { fHiddenLayer=hiddenl ayer; }	void SetHiddenLayer(TString hiddenlayer = "" ) { fHiddenLayer=hiddenl ayer; }

	// ranking of input variables	// ranking of input variables
	const Ranking* CreateRanking() { return 0; }	const Ranking* CreateRanking() { return 0; }

	// make ROOT-independent C++ class	// make ROOT-independent C++ class
	void MakeClass( const TString& classFileName = TString("") ) const;	void MakeClass( const TString& classFileName = TString("") ) const;

	protected:	protected:

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

	Minimizer.h	Minimizer.h

	// @(#)root/mathcore:$Id: Minimizer.h 31604 2009-12-07 19:04:33Z moneta $	// @(#)root/mathcore:$Id: Minimizer.h 36905 2010-11-24 15:44:34Z moneta $
	// Author: L. Moneta Fri Sep 22 15:06:47 2006	// Author: L. Moneta Fri Sep 22 15:06:47 2006

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for class Minimizer	// Header file for class Minimizer

	#ifndef ROOT_Math_Minimizer	#ifndef ROOT_Math_Minimizer
	#define ROOT_Math_Minimizer	#define ROOT_Math_Minimizer

	#ifndef ROOT_Math_IFunction	#ifndef ROOT_Math_IFunction
	#include "Math/IFunction.h"	#include "Math/IFunction.h"
	#endif	#endif


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

	#include <vector>	#include <vector>
	#include <string>	#include <string>

	#include <limits>	#include <limits>
	#include <cmath>	#include <cmath>


	//#define DEBUG
	#ifdef DEBUG
	#include <iostream>
	#endif

	namespace ROOT {	namespace ROOT {

	namespace Math {	namespace Math {

	/**	/**
	@defgroup MultiMin Multi-dimensional Minimization	@defgroup MultiMin Multi-dimensional Minimization
	@ingroup NumAlgo	@ingroup NumAlgo

	Classes implementing algorithms for multi-dimensional minimization	Classes implementing algorithms for multi-dimensional minimization
	*/	*/

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

	class Minimizer {	class Minimizer {

	public:	public:

	/**	/**
	Default constructor	Default constructor
	*/	*/
	Minimizer () :	Minimizer () :
	fValidError(false),	fValidError(false),

	#ifndef DEBUG	fDebug(MinimizerOptions::DefaultPrintLevel()),
	fDebug(0),	fStrategy(MinimizerOptions::DefaultStrategy()),
	#else
	fDebug(3),
	#endif
	fStrategy(1),
	fStatus(-1),	fStatus(-1),

	fMaxCalls(0),	fMaxCalls(MinimizerOptions::DefaultMaxFunctionCalls()),
	fMaxIter(0),	fMaxIter(MinimizerOptions::DefaultMaxIterations()),
	fTol(1.E-6),	fTol(MinimizerOptions::DefaultTolerance()),
	fPrec(-1),	fPrec(MinimizerOptions::DefaultPrecision()),
	fUp(1.)	fUp(MinimizerOptions::DefaultErrorDef() )
	{}	{}

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

	private:	private:
	// usually copying is non trivial, so we make this unaccessible	// usually copying is non trivial, so we make this unaccessible


	skipping to change at line 136	skipping to change at line 127
	virtual void SetFunction(const ROOT::Math::IMultiGradFunction & func)	virtual void SetFunction(const ROOT::Math::IMultiGradFunction & func)
	{	{
	SetFunction(static_cast<const ::ROOT::Math::IMultiGenFunction &> (fun c));	SetFunction(static_cast<const ::ROOT::Math::IMultiGenFunction &> (fun c));
	}	}

	/// add variables . Return number of variables succesfully added	/// add variables . Return number of variables succesfully added
	template<class VariableIterator>	template<class VariableIterator>
	int SetVariables(const VariableIterator & begin, const VariableIterator & end) {	int SetVariables(const VariableIterator & begin, const VariableIterator & end) {
	unsigned int ivar = 0;	unsigned int ivar = 0;
	for ( VariableIterator vitr = begin; vitr != end; ++vitr) {	for ( VariableIterator vitr = begin; vitr != end; ++vitr) {

	#ifdef DEBUG
	std::cout << "adding variable " << ivar << " " << vitr->Name();
	if (vitr->IsDoubleBound() ) std::cout << " bounded to [ " << vitr
	->LowerLimit() << " , " << vitr->UpperLimit() << " ] ";
	std::cout << std::endl;
	#endif
	bool iret = false;	bool iret = false;
	if (vitr->IsFixed() )	if (vitr->IsFixed() )
	iret = SetFixedVariable(ivar, vitr->Name(), vitr->Value() );	iret = SetFixedVariable(ivar, vitr->Name(), vitr->Value() );
	else if (vitr->IsDoubleBound() )	else if (vitr->IsDoubleBound() )
	iret = SetLimitedVariable(ivar, vitr->Name(), vitr->Value(), v itr->StepSize(), vitr->LowerLimit(), vitr->UpperLimit() );	iret = SetLimitedVariable(ivar, vitr->Name(), vitr->Value(), v itr->StepSize(), vitr->LowerLimit(), vitr->UpperLimit() );
	else if (vitr->HasLowerLimit() )	else if (vitr->HasLowerLimit() )
	iret = SetLowerLimitedVariable(ivar, vitr->Name(), vitr->Value (), vitr->StepSize(), vitr->LowerLimit() );	iret = SetLowerLimitedVariable(ivar, vitr->Name(), vitr->Value (), vitr->StepSize(), vitr->LowerLimit() );
	else if (vitr->HasUpperLimit() )	else if (vitr->HasUpperLimit() )
	iret = SetUpperLimitedVariable(ivar, vitr->Name(), vitr->Value (), vitr->StepSize(), vitr->UpperLimit() );	iret = SetUpperLimitedVariable(ivar, vitr->Name(), vitr->Value (), vitr->StepSize(), vitr->UpperLimit() );
	else	else
	iret = SetVariable( ivar, vitr->Name(), vitr->Value(), vitr->St epSize() );	iret = SetVariable( ivar, vitr->Name(), vitr->Value(), vitr->St epSize() );

	if (iret) ivar++;	if (iret) ivar++;

	#ifdef DEBUG
	if (iret)
	std::cout << "Added variable " << vitr->Name() << " val = " <<
	vitr->Value() << " step " << vitr->StepSize()
	<< std::endl;
	else
	std::cout << "Failed to Add variable " << vitr->Name() << std::
	endl;
	#endif


		// an error message should be eventually be reported in the virtua l single SetVariable methods
	}	}
	return ivar;	return ivar;
	}	}
	/// set free variable	/// set free variable
	virtual bool SetVariable(unsigned int ivar, const std::string & name, do uble val, double step) = 0;	virtual bool SetVariable(unsigned int ivar, const std::string & name, do uble val, double step) = 0;
	/// set lower limit variable (override if minimizer supports them )	/// set lower limit variable (override if minimizer supports them )
	virtual bool SetLowerLimitedVariable(unsigned int ivar , const std::str ing & name , double val , double step , double lower ) {	virtual bool SetLowerLimitedVariable(unsigned int ivar , const std::str ing & name , double val , double step , double lower ) {
	return SetLimitedVariable(ivar, name, val, step, lower, std::numeric_ limits<double>::infinity() );	return SetLimitedVariable(ivar, name, val, step, lower, std::numeric_ limits<double>::infinity() );
	}	}
	/// set upper limit variable (override if minimizer supports them )	/// set upper limit variable (override if minimizer supports them )

	skipping to change at line 310	skipping to change at line 290
	/// get index of variable given a variable given a name	/// get index of variable given a variable given a name
	/// return -1 if variable is not found	/// return -1 if variable is not found
	virtual int VariableIndex(const std::string &) const { return -1; }	virtual int VariableIndex(const std::string &) const { return -1; }

	/ minimizer configuration parameters /	/ minimizer configuration parameters /

	/// set print level	/// set print level
	int PrintLevel() const { return fDebug; }	int PrintLevel() const { return fDebug; }

	/// max number of function calls	/// max number of function calls

	unsigned int MaxFunctionCalls() { return fMaxCalls; }	unsigned int MaxFunctionCalls() const { return fMaxCalls; }

	/// max iterations	/// max iterations

	unsigned int MaxIterations() { return fMaxIter; }	unsigned int MaxIterations() const { return fMaxIter; }

	/// absolute tolerance	/// absolute tolerance
	double Tolerance() const { return fTol; }	double Tolerance() const { return fTol; }

	/// precision of minimizer in the evaluation of the objective function	/// precision of minimizer in the evaluation of the objective function
	/// ( a value <=0 corresponds to the let the minimizer choose its defaul t one)	/// ( a value <=0 corresponds to the let the minimizer choose its defaul t one)
	double Precision() const { return fPrec; }	double Precision() const { return fPrec; }

	/// strategy	/// strategy
	int Strategy() const { return fStrategy; }	int Strategy() const { return fStrategy; }

	skipping to change at line 335	skipping to change at line 315
	/// status code of minimizer	/// status code of minimizer
	int Status() const { return fStatus; }	int Status() const { return fStatus; }

	/// return the statistical scale used for calculate the error	/// return the statistical scale used for calculate the error
	/// is typically 1 for Chi2 and 0.5 for likelihood minimization	/// is typically 1 for Chi2 and 0.5 for likelihood minimization
	double ErrorDef() const { return fUp; }	double ErrorDef() const { return fUp; }

	///return true if Minimizer has performed a detailed error validation (e .g. run Hesse for Minuit)	///return true if Minimizer has performed a detailed error validation (e .g. run Hesse for Minuit)
	bool IsValidError() const { return fValidError; }	bool IsValidError() const { return fValidError; }


		/// retrieve the minimizer options (implement derived class if needed)
		virtual MinimizerOptions Options() const {
		MinimizerOptions opt;
		opt.SetPrintLevel(fDebug);
		opt.SetStrategy(fStrategy);
		opt.SetMaxFunctionCalls(fMaxCalls);
		opt.SetMaxIterations(fMaxIter);
		opt.SetTolerance(fTol);
		opt.SetPrecision(fPrec);
		opt.SetErrorDef(fUp);
		return opt;
		}

	/// set print level	/// set print level
	void SetPrintLevel(int level) { fDebug = level; }	void SetPrintLevel(int level) { fDebug = level; }

	///set maximum of function calls	///set maximum of function calls
	void SetMaxFunctionCalls(unsigned int maxfcn) { if (maxfcn > 0) fMaxCall s = maxfcn; }	void SetMaxFunctionCalls(unsigned int maxfcn) { if (maxfcn > 0) fMaxCall s = maxfcn; }

	/// set maximum iterations (one iteration can have many function calls)	/// set maximum iterations (one iteration can have many function calls)
	void SetMaxIterations(unsigned int maxiter) { if (maxiter > 0) fMaxIter = maxiter; }	void SetMaxIterations(unsigned int maxiter) { if (maxiter > 0) fMaxIter = maxiter; }

	/// set the tolerance	/// set the tolerance

	skipping to change at line 360	skipping to change at line 353

	///set the strategy	///set the strategy
	void SetStrategy(int strategyLevel) { fStrategy = strategyLevel; }	void SetStrategy(int strategyLevel) { fStrategy = strategyLevel; }

	/// set scale for calculating the errors	/// set scale for calculating the errors
	void SetErrorDef(double up) { fUp = up; }	void SetErrorDef(double up) { fUp = up; }

	/// flag to check if minimizer needs to perform accurate error analysis (e.g. run Hesse for Minuit)	/// flag to check if minimizer needs to perform accurate error analysis (e.g. run Hesse for Minuit)
	void SetValidError(bool on) { fValidError = on; }	void SetValidError(bool on) { fValidError = on; }


		/// set all options in one go
		void SetOptions(const MinimizerOptions & opt) {
		fDebug = opt.PrintLevel();
		fStrategy = opt.Strategy();
		fMaxCalls = opt.MaxFunctionCalls();
		fMaxIter = opt.MaxIterations();
		fTol = opt.Tolerance();
		fPrec = opt.Precision();
		fUp = opt.ErrorDef();
		}

		/// reset the defaut options (defined in MinimizerOptions)
		void SetDefaultOptions() {
		fDebug = MinimizerOptions::DefaultPrintLevel();
		fStrategy = MinimizerOptions::DefaultStrategy();
		fMaxCalls = MinimizerOptions::DefaultMaxFunctionCalls();
		fMaxIter = MinimizerOptions::DefaultMaxIterations();
		fTol = MinimizerOptions::DefaultTolerance();
		fPrec = MinimizerOptions::DefaultPrecision();
		fUp = MinimizerOptions::DefaultErrorDef();
		}

	protected:	protected:

	//private:	//private:

	// keep protected to be accessible by the derived classes	// keep protected to be accessible by the derived classes

	bool fValidError; // flag to control if errors have been vali dated (Hesse has been run in case of Minuit)	bool fValidError; // flag to control if errors have been vali dated (Hesse has been run in case of Minuit)
	int fDebug; // print level	int fDebug; // print level
	int fStrategy; // minimizer strategy	int fStrategy; // minimizer strategy
	int fStatus; // status of minimizer	int fStatus; // status of minimizer

End of changes. 12 change blocks.
	37 lines changed or deleted	49 lines changed or added

	MinimizerOptions.h	MinimizerOptions.h

	// @(#)root/mathcore:$Id: MinimizerOptions.h 31604 2009-12-07 19:04:33Z mon eta $	// @(#)root/mathcore:$Id: MinimizerOptions.h 36905 2010-11-24 15:44:34Z mon eta $
	// Author: L. Moneta Fri Aug 15 2008	// Author: L. Moneta Fri Aug 15 2008

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2008 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2008 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	#ifndef ROOT_Math_MinimizerOptions	#ifndef ROOT_Math_MinimizerOptions
	#define ROOT_Math_MinimizerOptions	#define ROOT_Math_MinimizerOptions

	#include <string>	#include <string>


		#include <iostream>

	namespace ROOT {	namespace ROOT {


	namespace Math {	namespace Math {

		class IOptions;

	//_________________________________________________________________________ ______	//_________________________________________________________________________ ______
	/**	/**
	Minimizer options	Minimizer options

	@ingroup MultiMin	@ingroup MultiMin
	*/	*/
	class MinimizerOptions {	class MinimizerOptions {

	public:	public:

	skipping to change at line 51	skipping to change at line 55
	static const std::string & DefaultMinimizerType();	static const std::string & DefaultMinimizerType();
	static const std::string & DefaultMinimizerAlgo();	static const std::string & DefaultMinimizerAlgo();
	static double DefaultErrorDef();	static double DefaultErrorDef();
	static double DefaultTolerance();	static double DefaultTolerance();
	static double DefaultPrecision();	static double DefaultPrecision();
	static int DefaultMaxFunctionCalls();	static int DefaultMaxFunctionCalls();
	static int DefaultMaxIterations();	static int DefaultMaxIterations();
	static int DefaultStrategy();	static int DefaultStrategy();
	static int DefaultPrintLevel();	static int DefaultPrintLevel();


		/// retrieve extra options - if not existing create a IOptions
		static ROOT::Math::IOptions & Default(const char * name);

		// find extra options - return 0 if not existing
		static ROOT::Math::IOptions * FindDefault(const char * name);

		/// print all the default options for the name given
		static void PrintDefault(const char * name = 0, std::ostream & os = std:
		:cout);

		public:

	// constructor using the default options	// constructor using the default options

	MinimizerOptions();	// pass optionally a pointer to the additional options
		// otehrwise look if they exist for this default minimizer
		// and in that case they are copied in the constructed instance
		MinimizerOptions(IOptions * extraOpts = 0);

		// destructor
		~MinimizerOptions();

		// copy constructor
		MinimizerOptions(const MinimizerOptions & opt);

		/// assignment operators
		MinimizerOptions & operator=(const MinimizerOptions & opt);

	/** non-static methods for retrivieng options */	/** non-static methods for retrivieng options */

	/// set print level	/// set print level
	int PrintLevel() const { return fLevel; }	int PrintLevel() const { return fLevel; }

	/// max number of function calls	/// max number of function calls
	unsigned int MaxFunctionCalls() const { return fMaxCalls; }	unsigned int MaxFunctionCalls() const { return fMaxCalls; }

	/// max iterations	/// max iterations

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

	/// absolute tolerance	/// absolute tolerance
	double Tolerance() const { return fTolerance; }	double Tolerance() const { return fTolerance; }

	/// precision in the objective funciton calculation (value <=0 means lef t to default)	/// precision in the objective funciton calculation (value <=0 means lef t to default)
	double Precision() const { return fPrecision; }	double Precision() const { return fPrecision; }

	/// error definition	/// error definition
	double ErrorDef() const { return fErrorDef; }	double ErrorDef() const { return fErrorDef; }


		/// return extra options (NULL pointer if they are not present)
		IOptions * ExtraOptions() const { return fExtraOptions; }

	/// type of minimizer	/// type of minimizer
	const std::string & MinimizerType() const { return fMinimType; }	const std::string & MinimizerType() const { return fMinimType; }

	/// type of algorithm	/// type of algorithm
	const std::string & MinimizerAlgorithm() const { return fAlgoType; }	const std::string & MinimizerAlgorithm() const { return fAlgoType; }


		/// print all the options
		void Print(std::ostream & os = std::cout) const;

	/** non-static methods for setting options */	/** non-static methods for setting options */

	/// set print level	/// set print level
	void SetPrintLevel(int level) { fLevel = level; }	void SetPrintLevel(int level) { fLevel = level; }

	///set maximum of function calls	///set maximum of function calls
	void SetMaxFunctionCalls(unsigned int maxfcn) { fMaxCalls = maxfcn; }	void SetMaxFunctionCalls(unsigned int maxfcn) { fMaxCalls = maxfcn; }

	/// set maximum iterations (one iteration can have many function calls)	/// set maximum iterations (one iteration can have many function calls)
	void SetMaxIterations(unsigned int maxiter) { fMaxIter = maxiter; }	void SetMaxIterations(unsigned int maxiter) { fMaxIter = maxiter; }

	skipping to change at line 112	skipping to change at line 145

	/// set error def	/// set error def
	void SetErrorDef(double err) { fErrorDef = err; }	void SetErrorDef(double err) { fErrorDef = err; }

	/// set minimizer type	/// set minimizer type
	void SetMinimizerType(const char * type) { fMinimType = type; }	void SetMinimizerType(const char * type) { fMinimType = type; }

	/// set minimizer algorithm	/// set minimizer algorithm
	void SetMinimizerAlgorithm(const char *type) { fAlgoType = type; }	void SetMinimizerAlgorithm(const char *type) { fAlgoType = type; }


		/// set extra options (in this case pointer is cloned)
		void SetExtraOptions(const IOptions & opt);

	private:	private:

	int fLevel; // debug print level	int fLevel; // debug print level
	int fMaxCalls; // maximum number of function calls	int fMaxCalls; // maximum number of function calls
	int fMaxIter; // maximum number of iterations	int fMaxIter; // maximum number of iterations
	int fStrategy; // minimizer strategy (used by Minuit)	int fStrategy; // minimizer strategy (used by Minuit)
	double fErrorDef; // error definition (=1. for getting 1 sigma e rror for chi2 fits)	double fErrorDef; // error definition (=1. for getting 1 sigma e rror for chi2 fits)
	double fTolerance; // minimize tolerance to reach solution	double fTolerance; // minimize tolerance to reach solution

	double fPrecision; // precision of the objective funciton evaluat ion (value <=0 means left to default)	double fPrecision; // precision of the objective function evaluat ion (value <=0 means left to default)
	std::string fMinimType; // Minimizer type (Minuit, Minuit2, etc..	std::string fMinimType; // Minimizer type (Minuit, Minuit2, etc..
	std::string fAlgoType; // Minimizer algorithmic specification (Migrad , Minimize, ...)	std::string fAlgoType; // Minimizer algorithmic specification (Migrad , Minimize, ...)


		// extra options
		ROOT::Math::IOptions * fExtraOptions; // extra options

	};	};

	} // end namespace Math	} // end namespace Math

	} // end namespace ROOT	} // end namespace ROOT

	#endif	#endif

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

	ModelConfig.h	ModelConfig.h

	// @(#)root/roostats:$Id: ModelConfig.h 34109 2010-06-24 15:00:16Z moneta $	// @(#)root/roostats:$Id: ModelConfig.h 37084 2010-11-29 21:37:13Z moneta $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke, S
		ven Kreiss
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, 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 ROOSTATS_ModelConfig	#ifndef ROOSTATS_ModelConfig
	#define ROOSTATS_ModelConfig	#define ROOSTATS_ModelConfig

	skipping to change at line 43	skipping to change at line 43

	#include <string>	#include <string>

	//_________________________________________________	//_________________________________________________
	/*	/*
	BEGIN_HTML	BEGIN_HTML
	<p>	<p>
	ModelConfig is a simple class that holds configuration information specifyi ng how a model	ModelConfig is a simple class that holds configuration information specifyi ng how a model
	should be used in the context of various RooStats tools. A single model ca n be used	should be used in the context of various RooStats tools. A single model ca n be used
	in different ways, and this class should carry all that is needed to specif y how it should be used.	in different ways, and this class should carry all that is needed to specif y how it should be used.

	ModelConfig requires a workspace to be set	ModelConfig requires a workspace to be set.
	</p>	</p>
	END_HTML	END_HTML
	*/	*/
	//	//

	namespace RooStats {	namespace RooStats {

	class ModelConfig : public TNamed {	class ModelConfig : public TNamed {

	public:	public:

	ModelConfig(RooWorkspace * ws = 0) :	ModelConfig(RooWorkspace * ws = 0) :

	TNamed(),	TNamed()
	fWS(ws)
	//fOwnsWorkspace(false)
	{	{

	if (ws) fWSName = ws->GetName();	if(ws) SetWS(*ws);
	}	}

	ModelConfig(const char* name, RooWorkspace *ws = 0) :	ModelConfig(const char* name, RooWorkspace *ws = 0) :

	TNamed(name, name),	TNamed(name, name)
	fWS(ws)
	//fOwnsWorkspace(false)
	{	{

	if (ws) fWSName = ws->GetName();	if(ws) SetWS(*ws);
	}	}

	ModelConfig(const char* name, const char* title, RooWorkspace *ws = 0) :	ModelConfig(const char* name, const char* title, RooWorkspace *ws = 0) :

	TNamed(name, title),	TNamed(name, title)
	fWS(ws)
	//fOwnsWorkspace(false)
	{	{

	if (ws) fWSName = ws->GetName();	if(ws) SetWS(*ws);
	}	}


	// destructor.
	virtual ~ModelConfig();

	// clone	// clone

	virtual ModelConfig * Clone(const char * name = "ModelConfig") const {	virtual ModelConfig * Clone(const char * name = "") const {
	ModelConfig * mc = new ModelConfig(*this);	ModelConfig * mc = new ModelConfig(*this);

	mc->SetName(name);	if(strcmp(name,"")==0)
		mc->SetName(this->GetName());
		else
		mc->SetName(name);
	return mc;	return mc;
	}	}

	// set a workspace that owns all the necessary components for the analys is	// set a workspace that owns all the necessary components for the analys is

	virtual void SetWorkspace(RooWorkspace & ws);	virtual void SetWS(RooWorkspace & ws);
		/// alias for SetWS(...)
		virtual void SetWorkspace(RooWorkspace & ws) { SetWS(ws); }

	// Set the proto DataSet, add to the the workspace if not already there	// Set the proto DataSet, add to the the workspace if not already there
	virtual void SetProtoData(RooAbsData & data) {	virtual void SetProtoData(RooAbsData & data) {
	ImportDataInWS(data);	ImportDataInWS(data);
	SetProtoData( data.GetName() );	SetProtoData( data.GetName() );
	}	}

	// Set the Pdf, add to the the workspace if not already there	// Set the Pdf, add to the the workspace if not already there
	virtual void SetPdf(const RooAbsPdf& pdf) {	virtual void SetPdf(const RooAbsPdf& pdf) {
	ImportPdfInWS(pdf);	ImportPdfInWS(pdf);

	skipping to change at line 155	skipping to change at line 151
	fGlobalObsName=std::string(GetName()) + "_GlobalObservables";	fGlobalObsName=std::string(GetName()) + "_GlobalObservables";
	DefineSetInWS(fGlobalObsName.c_str(), set);	DefineSetInWS(fGlobalObsName.c_str(), set);
	}	}

	// set parameter values for a particular hypothesis if using a common PD F	// set parameter values for a particular hypothesis if using a common PD F
	// by saving a snapshot in the workspace	// by saving a snapshot in the workspace
	virtual void SetSnapshot(const RooArgSet& set);	virtual void SetSnapshot(const RooArgSet& set);

	// specify the name of the PDF in the workspace to be used	// specify the name of the PDF in the workspace to be used
	virtual void SetPdf(const char* name) {	virtual void SetPdf(const char* name) {

	if(!fWS){	if (! GetWS() ) return;
	coutE(ObjectHandling) << "workspace not set" << endl;
	return;	if(GetWS()->pdf(name))
	}
	if(fWS->pdf(name))
	fPdfName = name;	fPdfName = name;
	else	else
	coutE(ObjectHandling) << "pdf "<<name<< " does not exist in worksp ace"<<endl;	coutE(ObjectHandling) << "pdf "<<name<< " does not exist in worksp ace"<<endl;
	}	}

	// specify the name of the PDF in the workspace to be used	// specify the name of the PDF in the workspace to be used
	virtual void SetPriorPdf(const char* name) {	virtual void SetPriorPdf(const char* name) {

	if(!fWS){	if (! GetWS() ) return;
	coutE(ObjectHandling) << "workspace not set" << endl;
	return;	if(GetWS()->pdf(name))
	}
	if(fWS->pdf(name))
	fPriorPdfName = name;	fPriorPdfName = name;
	else	else
	coutE(ObjectHandling) << "pdf "<<name<< " does not exist in worksp ace"<<endl;	coutE(ObjectHandling) << "pdf "<<name<< " does not exist in worksp ace"<<endl;
	}	}

	// specify the name of the dataset in the workspace to be used	// specify the name of the dataset in the workspace to be used
	virtual void SetProtoData(const char* name){	virtual void SetProtoData(const char* name){

	if(!fWS){	if (! GetWS() ) return;
	coutE(ObjectHandling) << "workspace not set" << endl;
	return;	if(GetWS()->data(name))
	}
	if(fWS->data(name))
	fProtoDataName = name;	fProtoDataName = name;
	else	else
	coutE(ObjectHandling) << "dataset "<<name<< " does not exist in wo rkspace"<<endl;	coutE(ObjectHandling) << "dataset "<<name<< " does not exist in wo rkspace"<<endl;
	}	}

	/* getter methods */	/* getter methods */

	/// get model PDF (return NULL if pdf has not been specified or does not exist)	/// get model PDF (return NULL if pdf has not been specified or does not exist)

	RooAbsPdf * GetPdf() const { return (fWS) ? fWS->pdf(fPdfName.c_str()) : 0; }	RooAbsPdf * GetPdf() const { return (GetWS()) ? GetWS()->pdf(fPdfName.c_ str()) : 0; }

	/// get RooArgSet containing the parameter of interest (return NULL if n ot existing)	/// get RooArgSet containing the parameter of interest (return NULL if n ot existing)

	const RooArgSet * GetParametersOfInterest() const { return (fWS) ? fWS-> set(fPOIName.c_str()) : 0; }	const RooArgSet * GetParametersOfInterest() const { return (GetWS()) ? G etWS()->set(fPOIName.c_str()) : 0; }

	/// get RooArgSet containing the nuisance parameters (return NULL if not existing)	/// get RooArgSet containing the nuisance parameters (return NULL if not existing)

	const RooArgSet * GetNuisanceParameters() const { return (fWS) ? fWS->se t(fNuisParamsName.c_str()) : 0; }	const RooArgSet * GetNuisanceParameters() const { return (GetWS()) ? Get WS()->set(fNuisParamsName.c_str()) : 0; }

	/// get RooArgSet containing the constraint parameters (return NULL if n ot existing)	/// get RooArgSet containing the constraint parameters (return NULL if n ot existing)

	const RooArgSet * GetConstraintParameters() const { return (fWS) ? fWS-> set(fConstrParamsName.c_str()) : 0; }	const RooArgSet * GetConstraintParameters() const { return (GetWS()) ? G etWS()->set(fConstrParamsName.c_str()) : 0; }

	/// get parameters prior pdf (return NULL if not existing)	/// get parameters prior pdf (return NULL if not existing)

	RooAbsPdf * GetPriorPdf() const { return (fWS) ? fWS->pdf(fPriorPdfName. c_str()) : 0; }	RooAbsPdf * GetPriorPdf() const { return (GetWS()) ? GetWS()->pdf(fPrior PdfName.c_str()) : 0; }

	/// get RooArgSet for observables (return NULL if not existing)	/// get RooArgSet for observables (return NULL if not existing)

	const RooArgSet * GetObservables() const { return (fWS) ? fWS->set(fObse rvablesName.c_str()) : 0; }	const RooArgSet * GetObservables() const { return (GetWS()) ? GetWS()->s et(fObservablesName.c_str()) : 0; }

	/// get RooArgSet for conditional observables (return NULL if not exist ing)	/// get RooArgSet for conditional observables (return NULL if not exist ing)

	const RooArgSet * GetConditionalObservables() const { return (fWS) ? fWS ->set(fConditionalObsName.c_str()) : 0; }	const RooArgSet * GetConditionalObservables() const { return (GetWS()) ? GetWS()->set(fConditionalObsName.c_str()) : 0; }

	/// get RooArgSet for global observables (return NULL if not existing)	/// get RooArgSet for global observables (return NULL if not existing)

	const RooArgSet * GetGlobalObservables() const { return (fWS) ? fWS->set (fGlobalObsName.c_str()) : 0; }	const RooArgSet * GetGlobalObservables() const { return (GetWS()) ? GetW S()->set(fGlobalObsName.c_str()) : 0; }

	/// get Proto data set (return NULL if not existing)	/// get Proto data set (return NULL if not existing)

	RooAbsData * GetProtoData() const { return (fWS) ? fWS->data(fProtoDat aName.c_str()) : 0; }	RooAbsData * GetProtoData() const { return (GetWS()) ? GetWS()->data(f ProtoDataName.c_str()) : 0; }

	/// get RooArgSet for parameters for a particular hypothesis (return NU LL if not existing)	/// get RooArgSet for parameters for a particular hypothesis (return NU LL if not existing)
	const RooArgSet * GetSnapshot() const;	const RooArgSet * GetSnapshot() const;

	void LoadSnapshot() const;	void LoadSnapshot() const;

	RooWorkspace * GetWS() const;	RooWorkspace * GetWS() const;

		/// alias for GetWS()
		RooWorkspace * GetWorkspace() const { return GetWS(); }

	/// guesses Observables and ParametersOfInterest if not already set	/// guesses Observables and ParametersOfInterest if not already set
	void GuessObsAndNuisance(const RooAbsData& data);	void GuessObsAndNuisance(const RooAbsData& data);


		// overload the print method
		virtual void Print(Option_t* option = "") const;

	protected:	protected:
	// helper functions to define a set in the WS	// helper functions to define a set in the WS
	void DefineSetInWS(const char* name, const RooArgSet& set);	void DefineSetInWS(const char* name, const RooArgSet& set);

	// internal function to import Pdf in WS	// internal function to import Pdf in WS
	void ImportPdfInWS(const RooAbsPdf & pdf);	void ImportPdfInWS(const RooAbsPdf & pdf);

	// internal function to import data in WS	// internal function to import data in WS
	void ImportDataInWS(RooAbsData & data);	void ImportDataInWS(RooAbsData & data);


	mutable RooWorkspace* fWS; //! a workspace that owns all the compone nts to be used by the calculator (transient member)
	TRef fRefWS; // WS reference used in the file	TRef fRefWS; // WS reference used in the file


	//Bool_t fOwnsWorkspace;

	std::string fWSName; // name of the WS	std::string fWSName; // name of the WS

	std::string fPdfName; // name of PDF in workspace	std::string fPdfName; // name of PDF in workspace
	std::string fDataName; // name of data set in workspace	std::string fDataName; // name of data set in workspace
	std::string fPOIName; // name for RooArgSet specifying parameters of int erest	std::string fPOIName; // name for RooArgSet specifying parameters of int erest

	std::string fNuisParamsName; // name for RooArgSet specifying nuisance p arameters	std::string fNuisParamsName; // name for RooArgSet specifying nuisance p arameters
	std::string fConstrParamsName; // name for RooArgSet specifying constrai ned parameters	std::string fConstrParamsName; // name for RooArgSet specifying constrai ned parameters
	std::string fPriorPdfName; // name for RooAbsPdf specifying a prior on t he parameters	std::string fPriorPdfName; // name for RooAbsPdf specifying a prior on t he parameters

	std::string fConditionalObsName; // name for RooArgSet specifying condit ional observables	std::string fConditionalObsName; // name for RooArgSet specifying condit ional observables
	std::string fGlobalObsName; // name for RooArgSet specifying global obse rvables	std::string fGlobalObsName; // name for RooArgSet specifying global obse rvables
	std::string fProtoDataName; // name for RooArgSet specifying dataset tha t should be used as protodata	std::string fProtoDataName; // name for RooArgSet specifying dataset tha t should be used as protodata

	std::string fSnapshotName; // name for RooArgSet that specifies a partic ular hypothesis	std::string fSnapshotName; // name for RooArgSet that specifies a partic ular hypothesis

	std::string fObservablesName; // name for RooArgSet specifying observabl e parameters.	std::string fObservablesName; // name for RooArgSet specifying observabl e parameters.


	ClassDef(ModelConfig,3) // A class that holds configuration information for a model using a workspace as a store	ClassDef(ModelConfig,4) // A class that holds configuration information for a model using a workspace as a store

	};	};

	} // end namespace RooStats	} // end namespace RooStats

	#endif	#endif

End of changes. 29 change blocks.
	49 lines changed or deleted	42 lines changed or added

	MsgLogger.h	MsgLogger.h

	// @(#)root/tmva $Id: MsgLogger.h 35732 2010-09-25 11:49:37Z stelzer $	// @(#)root/tmva $Id: MsgLogger.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Attila Krasznahorkay	// Author: Attila Krasznahorkay

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MsgLogger *	* Class : MsgLogger *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* TMVA output logger class producing nicely formatted log messages *	* TMVA output logger class producing nicely formatted log messages *

	skipping to change at line 103	skipping to change at line 103
	}	}

	// Temporaly disables all the loggers (Caution! Use with care !)	// Temporaly disables all the loggers (Caution! Use with care !)
	static void InhibitOutput();	static void InhibitOutput();
	static void EnableOutput();	static void EnableOutput();

	private:	private:

	// private utility routines	// private utility routines
	void Send();	void Send();

	static void InitMaps();	void InitMaps();
	void WriteMsg( EMsgType type, const std::string& line ) const;	void WriteMsg( EMsgType type, const std::string& line ) const;


	const TObject* fObjSource; // the source TObjec	const TObject* fObjSource; // the source TObject (us
	t (used for name)	ed for name)
	std::string fStrSource; // alternative strin	std::string fStrSource; // alternative string sou
	g source	rce
	static const std::string fgPrefix; // the prefi	static const std::string fgPrefix; // the prefix of the sour
	x of the source name	ce name
	static const std::string fgSuffix; // suffix fo	static const std::string fgSuffix; // suffix following sourc
	llowing source name	e name
	EMsgType fActiveType; // active type	EMsgType fActiveType; // active type
	static UInt_t fgMaxSourceSize; // maximum length of	static UInt_t fgMaxSourceSize; // maximum length of sour
	source name	ce name
	static Bool_t fgOutputSupressed; // disable the out	static Bool_t fgOutputSupressed; // disable the output glo
	put globaly (used by generic booster)	baly (used by generic booster)
		static Bool_t fgInhibitOutput; // flag to suppress all o
	static std::map<EMsgType, std::string> fgTypeMap; // matches o	utput
	utput types with strings	static Int_t fgInstanceCounter; // counts open MsgLogger
	static std::map<EMsgType, std::string> fgColorMap; // matches o	instances
	utput types with terminal colors
	EMsgType fMinType; // minimum type for	static std::map<EMsgType, std::string>* fgTypeMap; // matches outpu
	output	t types with strings
		static std::map<EMsgType, std::string>* fgColorMap; // matches outpu
	static Bool_t fgInhibitOutput; // flag to suppress	t types with terminal colors
	all output	EMsgType fMinType; // minimum type
		for output

	ClassDef(MsgLogger,0) // Ostringstream derivative to redirect and for mat logging output	ClassDef(MsgLogger,0) // Ostringstream derivative to redirect and for mat logging output
	}; // class MsgLogger	}; // class MsgLogger

	inline MsgLogger& MsgLogger::operator<< ( MsgLogger& (*_f)( MsgLogger& ) )	inline MsgLogger& MsgLogger::operator<< ( MsgLogger& (*_f)( MsgLogger& ) )
	{	{
	return (_f)(*this);	return (_f)(*this);
	}	}

	inline MsgLogger& MsgLogger::operator<< ( std::ostream& (*_f)( std::ostr eam& ) )	inline MsgLogger& MsgLogger::operator<< ( std::ostream& (*_f)( std::ostr eam& ) )

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

	MultiNumGradFunction.h	MultiNumGradFunction.h

	// @(#)root/mathmore:$Id: MultiNumGradFunction.h 29068 2009-06-17 16:28:51Z moneta $	// @(#)root/mathmore:$Id: MultiNumGradFunction.h 37448 2010-12-09 20:20:56Z moneta $
	// Author: L. Moneta Wed Dec 20 14:36:31 2006	// Author: L. Moneta Wed Dec 20 14:36:31 2006

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* This library is free software; you can redistribute it and/or *	* This library is free software; you can redistribute it and/or *
	* modify it under the terms of the GNU General Public License *	* modify it under the terms of the GNU General Public License *
	* as published by the Free Software Foundation; either version 2 *	* as published by the Free Software Foundation; either version 2 *
	* of the License, or (at your option) any later version. *	* of the License, or (at your option) any later version. *

	skipping to change at line 59	skipping to change at line 59
	class MultiNumGradFunction : public IMultiGradFunction {	class MultiNumGradFunction : public IMultiGradFunction {

	public:	public:

	/**	/**
	Constructor from a IMultiGenFunction interface	Constructor from a IMultiGenFunction interface
	*/	*/
	MultiNumGradFunction (const IMultiGenFunction & f) :	MultiNumGradFunction (const IMultiGenFunction & f) :
	fFunc(&f),	fFunc(&f),
	fDim(f.NDim() ),	fDim(f.NDim() ),

		fNCalls(0),
	fOwner(false)	fOwner(false)
	{}	{}

	/**	/**
	Constructor from a generic function (pointer or reference) and number of dimension	Constructor from a generic function (pointer or reference) and number of dimension
	implementiong operator () (double * x)	implementiong operator () (double * x)
	*/	*/

	template<class FuncType>	template<class FuncType>
	MultiNumGradFunction (FuncType f, int n) :	MultiNumGradFunction (FuncType f, int n) :
	fDim( n ),	fDim( n ),

		fNCalls(0),
	fOwner(true)	fOwner(true)
	{	{
	// create a wrapped function	// create a wrapped function
	fFunc = new ROOT::Math::WrappedMultiFunction<FuncType> (f, n);	fFunc = new ROOT::Math::WrappedMultiFunction<FuncType> (f, n);
	}	}

	/**	/**
	Destructor (no operations)	Destructor (no operations)
	*/	*/
	~MultiNumGradFunction () {	~MultiNumGradFunction () {
	if (fOwner) delete fFunc;	if (fOwner) delete fFunc;
	}	}

	// method inheritaed from IFunction interface	// method inheritaed from IFunction interface

	unsigned int NDim() const { return fDim; }	unsigned int NDim() const { return fDim; }


		unsigned int NCalls() const { return fNCalls; }

	IMultiGenFunction * Clone() const {	IMultiGenFunction * Clone() const {
	if (!fOwner)	if (!fOwner)
	return new MultiNumGradFunction(*fFunc);	return new MultiNumGradFunction(*fFunc);
	else {	else {
	// we need to copy the pointer to the wrapped function	// we need to copy the pointer to the wrapped function
	MultiNumGradFunction * f = new MultiNumGradFunction(*(fFunc->Clon e()) );	MultiNumGradFunction * f = new MultiNumGradFunction(*(fFunc->Clon e()) );
	f->fOwner = true;	f->fOwner = true;
	return f;	return f;
	}	}
	}	}

	skipping to change at line 108	skipping to change at line 112
	/// precision value used for calculating the derivative step-size	/// precision value used for calculating the derivative step-size
	/// h = eps * \|x\|. The default is 0.001, give a smaller in case function chanes rapidly	/// h = eps * \|x\|. The default is 0.001, give a smaller in case function chanes rapidly
	static void SetDerivPrecision(double eps);	static void SetDerivPrecision(double eps);

	/// get precision value used for calculating the derivative step-size	/// get precision value used for calculating the derivative step-size
	static double GetDerivPrecision();	static double GetDerivPrecision();

	private:	private:

	double DoEval(const double * x) const {	double DoEval(const double * x) const {

		fNCalls++;
	return (*fFunc)(x);	return (*fFunc)(x);
	}	}

	// calculate derivative using mathcore derivator	// calculate derivative using mathcore derivator
	double DoDerivative (const double * x, unsigned int icoord ) const;	double DoDerivative (const double * x, unsigned int icoord ) const;

	// adapat internal function type to IMultiGenFunction needed by derivati ve calculation	// adapat internal function type to IMultiGenFunction needed by derivati ve calculation
	const IMultiGenFunction * fFunc;	const IMultiGenFunction * fFunc;
	unsigned int fDim;	unsigned int fDim;

		mutable unsigned int fNCalls;
	bool fOwner;	bool fOwner;

	static double fgEps; // epsilon used in derivative calculation h ~ eps \|x\|	static double fgEps; // epsilon used in derivative calculation h ~ eps \|x\|

	};	};

	} // end namespace Math	} // end namespace Math

	} // end namespace ROOT	} // end namespace ROOT


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

	NeymanConstruction.h	NeymanConstruction.h

	// @(#)root/roostats:$Id: NeymanConstruction.h 34109 2010-06-24 15:00:16Z m oneta $	// @(#)root/roostats:$Id: NeymanConstruction.h 37403 2010-12-08 15:59:22Z m oneta $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, 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 ROOSTATS_NeymanConstruction	#ifndef ROOSTATS_NeymanConstruction

	skipping to change at line 25	skipping to change at line 25
	#include "Rtypes.h"	#include "Rtypes.h"
	#endif	#endif

	#ifndef ROOSTATS_IntervalCalculator	#ifndef ROOSTATS_IntervalCalculator
	#include "RooStats/IntervalCalculator.h"	#include "RooStats/IntervalCalculator.h"
	#endif	#endif

	#include "RooStats/TestStatSampler.h"	#include "RooStats/TestStatSampler.h"
	#include "RooStats/ModelConfig.h"	#include "RooStats/ModelConfig.h"
	#include "RooStats/ConfidenceBelt.h"	#include "RooStats/ConfidenceBelt.h"

		#include "RooStats/PointSetInterval.h"

	#include "RooAbsData.h"	#include "RooAbsData.h"
	#include "RooAbsPdf.h"	#include "RooAbsPdf.h"
	#include "RooArgSet.h"	#include "RooArgSet.h"
	#include "TList.h"	#include "TList.h"

	class RooAbsData;	class RooAbsData;

	namespace RooStats {	namespace RooStats {


	skipping to change at line 47	skipping to change at line 48
	class NeymanConstruction : public IntervalCalculator{	class NeymanConstruction : public IntervalCalculator{

	public:	public:

	// NeymanConstruction();	// NeymanConstruction();
	NeymanConstruction(RooAbsData& data, ModelConfig& model);	NeymanConstruction(RooAbsData& data, ModelConfig& model);

	virtual ~NeymanConstruction();	virtual ~NeymanConstruction();

	// Main interface to get a ConfInterval (will be a PointSetInterval)	// Main interface to get a ConfInterval (will be a PointSetInterval)

	virtual ConfInterval* GetInterval() const;	virtual PointSetInterval* GetInterval() const;

	// in addition to interface we also need:	// in addition to interface we also need:
	// Set the TestStatSampler (eg. ToyMC or FFT, includes choice of Test Statistic)	// Set the TestStatSampler (eg. ToyMC or FFT, includes choice of Test Statistic)
	void SetTestStatSampler(TestStatSampler& sampler) {fTestStatSampler = &sampler;}	void SetTestStatSampler(TestStatSampler& sampler) {fTestStatSampler = &sampler;}
	// fLeftSideTailFraction*fSize defines lower edge of acceptance regio n.	// fLeftSideTailFraction*fSize defines lower edge of acceptance regio n.
	// Unified limits use 0, central limits use 0.5,	// Unified limits use 0, central limits use 0.5,
	// for upper/lower limits it is 0/1 depends on sign of test statistic w.r.t. parameter	// for upper/lower limits it is 0/1 depends on sign of test statistic w.r.t. parameter
	void SetLeftSideTailFraction(Double_t leftSideFraction = 0.) {fLeftSi deFraction = leftSideFraction;}	void SetLeftSideTailFraction(Double_t leftSideFraction = 0.) {fLeftSi deFraction = leftSideFraction;}

	// User-defined set of points to test	// User-defined set of points to test

	skipping to change at line 118	skipping to change at line 119
	void AdditionalNToysFactor(double fact){fAdditionalNToysFactor = fact ;}	void AdditionalNToysFactor(double fact){fAdditionalNToysFactor = fact ;}

	// save teh confidence belt to a file	// save teh confidence belt to a file
	void SaveBeltToFile(bool flag=true){	void SaveBeltToFile(bool flag=true){
	fSaveBeltToFile = flag;	fSaveBeltToFile = flag;
	if(flag) fCreateBelt = true;	if(flag) fCreateBelt = true;
	}	}
	// should create confidence belt	// should create confidence belt
	void CreateConfBelt(bool flag=true){fCreateBelt = flag;}	void CreateConfBelt(bool flag=true){fCreateBelt = flag;}


		// Returns instance of TestStatSampler. Use to change properties of
		// TestStatSampler, e.g. GetTestStatSampler.SetTestSize(Double_t size
		);
		TestStatSampler* GetTestStatSampler(void) { return fTestStatSampler;
		}

	private:	private:

	Double_t fSize; // size of the test (eg. specified rate of Type I err or)	Double_t fSize; // size of the test (eg. specified rate of Type I err or)
	RooAbsData& fData; // data set	RooAbsData& fData; // data set
	ModelConfig &fModel;	ModelConfig &fModel;
	/*	/*
	RooAbsPdf * fPdf; // common PDF	RooAbsPdf * fPdf; // common PDF
	mutable RooArgSet fPOI; // RooArgSet specifying parameters of intere st for interval	mutable RooArgSet fPOI; // RooArgSet specifying parameters of intere st for interval
	RooArgSet fNuisParams;// RooArgSet specifying nuisance parameters fo r interval	RooArgSet fNuisParams;// RooArgSet specifying nuisance parameters fo r interval
	*/	*/

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

	Node.h	Node.h

	// @(#)root/tmva $Id: Node.h 33928 2010-06-15 16:19:31Z stelzer $	// @(#)root/tmva $Id: Node.h 37399 2010-12-08 15:22:07Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Classes: Node *	* Classes: Node *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Node for the BinarySearch or Decision Trees *	* Node for the BinarySearch or Decision Trees *

	skipping to change at line 90	skipping to change at line 90

	virtual Node* CreateNode() const = 0;	virtual Node* CreateNode() const = 0;

	// test event if i{ decends the tree at this node to the right	// test event if i{ decends the tree at this node to the right
	virtual Bool_t GoesRight( const Event& ) const = 0;	virtual Bool_t GoesRight( const Event& ) const = 0;
	// test event if it decends the tree at this node to the left	// test event if it decends the tree at this node to the left

	virtual Bool_t GoesLeft ( const Event& ) const = 0;	virtual Bool_t GoesLeft ( const Event& ) const = 0;
	// test event if it is equal to the event that "makes the node" (just for the "search tree"	// test event if it is equal to the event that "makes the node" (just for the "search tree"


	// return pointer to the left daughter node	// return pointer to the left/right daughter or parent node
	inline Node* GetLeft () const { return fLeft; }	inline virtual Node* GetLeft () const { return fLeft; }
	// return pointer to the right daughter node	inline virtual Node* GetRight () const { return fRight; }
	inline Node* GetRight () const { return fRight; }	inline virtual Node* GetParent() const { return fParent; }
	// return pointer to the parent node
	inline Node* GetParent() const { return fParent; }	// set pointer to the left/right daughter or parent node
		inline virtual void SetLeft (Node* l) { fLeft = l;}
	// set pointer to the left daughter node	inline virtual void SetRight (Node* r) { fRight = r;}
	inline void SetLeft (Node* l) { fLeft = l;}	inline virtual void SetParent(Node* p) { fParent = p;}
	// set pointer to the right daughter node
	inline void SetRight (Node* r) { fRight = r;}
	// set pointer to the parent node
	inline void SetParent(Node* p) { fParent = p;}

	//recursively go through the part of the tree below this node and cou nt all daughters	//recursively go through the part of the tree below this node and cou nt all daughters
	Int_t CountMeAndAllDaughters() const;	Int_t CountMeAndAllDaughters() const;

	// printout of the node	// printout of the node
	virtual void Print( std::ostream& os ) const = 0;	virtual void Print( std::ostream& os ) const = 0;

	// recursive printout of the node and it daughters	// recursive printout of the node and it daughters
	virtual void PrintRec ( std::ostream& os ) const = 0;	virtual void PrintRec ( std::ostream& os ) const = 0;


	skipping to change at line 131	skipping to change at line 127
	// Return depth, layer of the where the node is within the tree, seen from the top (root)	// Return depth, layer of the where the node is within the tree, seen from the top (root)
	UInt_t GetDepth() const {return fDepth;}	UInt_t GetDepth() const {return fDepth;}

	// set node position, i.e, the node is a left (l) or right (r) daugth er	// set node position, i.e, the node is a left (l) or right (r) daugth er
	void SetPos(char s) {fPos=s;}	void SetPos(char s) {fPos=s;}

	// Return the node position, i.e, the node is a left (l) or right (r) daugther	// Return the node position, i.e, the node is a left (l) or right (r) daugther
	char GetPos() const {return fPos;}	char GetPos() const {return fPos;}

	// Return the pointer to the Parent tree to which the Node belongs	// Return the pointer to the Parent tree to which the Node belongs

	TMVA::BinaryTree* GetParentTree() const {return fParentTree;}	virtual TMVA::BinaryTree* GetParentTree() const {return fParentTree;}

	// set the pointer to the Parent Tree to which the Node belongs	// set the pointer to the Parent Tree to which the Node belongs

	void SetParentTree(TMVA::BinaryTree* t) {fParentTree = t;}	virtual void SetParentTree(TMVA::BinaryTree* t) {fParentTree = t;}

	int GetCount();	int GetCount();

	virtual Bool_t ReadDataRecord( std::istream&, UInt_t tmva_Version_Cod e = TMVA_VERSION_CODE ) = 0;	virtual Bool_t ReadDataRecord( std::istream&, UInt_t tmva_Version_Cod e = TMVA_VERSION_CODE ) = 0;
	virtual void ReadAttributes(void* node, UInt_t tmva_Version_Code = TM VA_VERSION_CODE ) = 0;	virtual void ReadAttributes(void* node, UInt_t tmva_Version_Code = TM VA_VERSION_CODE ) = 0;
	virtual void ReadContent(std::stringstream& s) =0;	virtual void ReadContent(std::stringstream& s) =0;


	private:	protected:

	Node* fParent; // the previous (parent) node	Node* fParent; // the previous (parent) node
	Node* fLeft; // pointers to the two "daughter" nodes	Node* fLeft; // pointers to the two "daughter" nodes
	Node* fRight; // pointers to the two "daughter" nodes	Node* fRight; // pointers to the two "daughter" nodes

	char fPos; // position, i.e. it is a left (l) or r ight (r) daughter	char fPos; // position, i.e. it is a left (l) or r ight (r) daughter
	UInt_t fDepth; // depth of the node within the tree (s een from root node)	UInt_t fDepth; // depth of the node within the tree (s een from root node)

	BinaryTree* fParentTree; // pointer to the parent tree to which the Node belongs	BinaryTree* fParentTree; // pointer to the parent tree to which the Node belongs

		private:

	static Int_t fgCount; // counter of all nodes present.. for d ebug.. to spot memory leaks...	static Int_t fgCount; // counter of all nodes present.. for d ebug.. to spot memory leaks...

	public:	public:
	ClassDef(Node,0) // Node for the BinarySearch or Decision Trees	ClassDef(Node,0) // Node for the BinarySearch or Decision Trees
	};	};

	} // namespace TMVA	} // namespace TMVA

	#endif	#endif

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

	NumEventsTestStat.h	NumEventsTestStat.h

	// @(#)root/roostats:$Id: NumEventsTestStat.h 31276 2009-11-18 15:06:42Z mo neta $	// @(#)root/roostats:$Id: NumEventsTestStat.h 36222 2010-10-09 18:27:06Z wo uter $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, 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 ROOSTATS_NumEventsTestStat	#ifndef ROOSTATS_NumEventsTestStat

	skipping to change at line 52	skipping to change at line 52
	NumEventsTestStat(RooAbsPdf& pdf) {	NumEventsTestStat(RooAbsPdf& pdf) {
	fPdf = &pdf;	fPdf = &pdf;
	}	}
	virtual ~NumEventsTestStat() {	virtual ~NumEventsTestStat() {
	// delete fRand;	// delete fRand;
	// delete fTestStatistic;	// delete fTestStatistic;
	}	}

	// Main interface to evaluate the test statistic on a dataset	// Main interface to evaluate the test statistic on a dataset
	virtual Double_t Evaluate(RooAbsData& data, RooArgSet& /paramsOfInter est/) {	virtual Double_t Evaluate(RooAbsData& data, RooArgSet& /paramsOfInter est/) {

	if(!&data){ cout << "problem with data" << endl;}	if(!&data) {
		cout << "problem with data" << endl;
	RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL) ;	return 0 ;
		} else {
	return data.numEntries();
		RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL) ;
		return data.numEntries();
		}
	}	}

	// Get the TestStatistic	// Get the TestStatistic
	virtual const RooAbsArg* GetTestStatistic() const {return fPdf;}	virtual const RooAbsArg* GetTestStatistic() const {return fPdf;}

	virtual const TString GetVarName() const {return "Number of events";}	virtual const TString GetVarName() const {return "Number of events";}

	private:	private:
	RooAbsPdf* fPdf;	RooAbsPdf* fPdf;


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

	Object.h	Object.h

	// @(#)root/reflex:$Id: Object.h 29288 2009-07-01 13:03:35Z axel $	// @(#)root/reflex:$Id: Object.h 36314 2010-10-12 12:40:57Z axel $
	// Author: Stefan Roiser 2004	// Author: Stefan Roiser 2004

	// Copyright CERN, CH-1211 Geneva 23, 2004-2006, All rights reserved.	// Copyright CERN, CH-1211 Geneva 23, 2004-2006, All rights reserved.
	//	//
	// Permission to use, copy, modify, and distribute this software for any	// Permission to use, copy, modify, and distribute this software for any
	// purpose is hereby granted without fee, provided that this copyright and	// purpose is hereby granted without fee, provided that this copyright and
	// permissions notice appear in all copies and derivatives.	// permissions notice appear in all copies and derivatives.
	//	//
	// This software is provided "as is" without express or implied warranty.	// This software is provided "as is" without express or implied warranty.


	skipping to change at line 215	skipping to change at line 215
	/**	/**
	* Object_Cast can be used to cast an object into a given type	* Object_Cast can be used to cast an object into a given type
	* (no additional checks are performed for the time being)	* (no additional checks are performed for the time being)
	* @param o the object to be casted	* @param o the object to be casted
	* @return the address of the object casted into type T	* @return the address of the object casted into type T
	*/	*/
	template <class T> T Object_Cast(const Object& o);	template <class T> T Object_Cast(const Object& o);

	} // namespace Reflex	} // namespace Reflex


	#include "Reflex/Member.h"
	#include "Reflex/Tools.h"	#include "Reflex/Tools.h"

	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	template <class T>	template <class T>
	inline T	inline T
	Reflex::Object_Cast(const Object& o) {	Reflex::Object_Cast(const Object& o) {
	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	return (T) o.Address();	return (T) o.Address();
	}	}


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

	PDEFoam.h	PDEFoam.h

	skipping to change at line 30	skipping to change at line 30
	* *	* *
	* Redistribution and use in source and binary forms, with or without *	* Redistribution and use in source and binary forms, with or without *
	* modification, are permitted according to the terms listed in LICENSE *	* modification, are permitted according to the terms listed in LICENSE *
	* (http://tmva.sourceforge.net/LICENSE) *	* (http://tmva.sourceforge.net/LICENSE) *
	************************************************************************ ******/	************************************************************************ ******/

	#ifndef ROOT_TMVA_PDEFoam	#ifndef ROOT_TMVA_PDEFoam
	#define ROOT_TMVA_PDEFoam	#define ROOT_TMVA_PDEFoam

	#include <iosfwd>	#include <iosfwd>

		#include <cassert>

	#ifndef ROOT_TH2D	#ifndef ROOT_TH2D
	#include "TH2D.h"	#include "TH2D.h"
	#endif	#endif
	#ifndef ROOT_TObjArray	#ifndef ROOT_TObjArray
	#include "TObjArray.h"	#include "TObjArray.h"
	#endif	#endif
	#ifndef ROOT_TObjString	#ifndef ROOT_TObjString
	#include "TObjString.h"	#include "TObjString.h"
	#endif	#endif

	skipping to change at line 59	skipping to change at line 60
	#ifndef ROOT_TMVA_Timer	#ifndef ROOT_TMVA_Timer
	#include "TMVA/Timer.h"	#include "TMVA/Timer.h"
	#endif	#endif
	#ifndef ROOT_TObject	#ifndef ROOT_TObject
	#include "TObject.h"	#include "TObject.h"
	#endif	#endif
	#ifndef ROOT_TRandom3	#ifndef ROOT_TRandom3
	#include "TRandom3.h"	#include "TRandom3.h"
	#endif	#endif


		namespace TMVA {
		class PDEFoamCell;
		class PDEFoamVect;
		class PDEFoamDistr;
		class PDEFoam;

		enum EFoamType { kSeparate, kDiscr, kMonoTarget, kMultiTarget };
		}

	#ifndef ROOT_TMVA_PDEFoamDistr	#ifndef ROOT_TMVA_PDEFoamDistr
	#include "TMVA/PDEFoamDistr.h"	#include "TMVA/PDEFoamDistr.h"
	#endif	#endif
	#ifndef ROOT_TMVA_PDEFoamVect	#ifndef ROOT_TMVA_PDEFoamVect
	#include "TMVA/PDEFoamVect.h"	#include "TMVA/PDEFoamVect.h"
	#endif	#endif
	#ifndef ROOT_TMVA_PDEFoamCell	#ifndef ROOT_TMVA_PDEFoamCell
	#include "TMVA/PDEFoamCell.h"	#include "TMVA/PDEFoamCell.h"
	#endif	#endif

	namespace TMVA {	namespace TMVA {

	class PDEFoam;	enum EKernel { kNone=0, kGaus=1, kLinN=2 };
	class PDEFoamCell;	enum ETargetSelection { kMean=0, kMpv=1 };

	enum EKernel { kNone, kGaus, kLinN };
	enum ETargetSelection { kMean, kMpv };
	enum ECellType { kAll, kActive, kInActive };	enum ECellType { kAll, kActive, kInActive };

	// enum type for possible foam cell values	// enum type for possible foam cell values
	// kNev : number of events (saved in cell element 0)	// kNev : number of events (saved in cell element 0)
	// kDiscriminator : discriminator (saved in cell element 0)	// kDiscriminator : discriminator (saved in cell element 0)
	// kDiscriminatorError : error on discriminator (saved in cell element 1 )	// kDiscriminatorError : error on discriminator (saved in cell element 1 )
	// kTarget0 : target 0 (saved in cell element 0)	// kTarget0 : target 0 (saved in cell element 0)
	// kTargetError : error on target 0 (saved in cell element 1)	// kTargetError : error on target 0 (saved in cell element 1)
	// kMeanValue : mean sampling value (saved in fIntegral)	// kMeanValue : mean sampling value (saved in fIntegral)
	// kRms : rms of sampling distribution (saved in fDriver)	// kRms : rms of sampling distribution (saved in fDriver)
	// kRmsOvMean : rms/mean of sampling distribution (saved in	// kRmsOvMean : rms/mean of sampling distribution (saved in
	// fDriver and fIntegral)	// fDriver and fIntegral)
	// kDensity : number of events/cell volume	// kDensity : number of events/cell volume
	enum ECellValue { kNev, kDiscriminator, kDiscriminatorError, kTarget0,	enum ECellValue { kNev, kDiscriminator, kDiscriminatorError, kTarget0,
	kTarget0Error, kMeanValue, kRms, kRmsOvMean, kDensity };	kTarget0Error, kMeanValue, kRms, kRmsOvMean, kDensity };

		// separation quantity to use (kFoam: use PDEFoam algorithm)
		enum EDTSeparation { kFoam, kGiniIndex, kMisClassificationError,
		kCrossEntropy };
	}	}

	namespace TMVA {	namespace TMVA {

	std::ostream& operator<< ( std::ostream& os, const PDEFoam& pdefoam );	std::ostream& operator<< ( std::ostream& os, const PDEFoam& pdefoam );
	std::istream& operator>> ( std::istream& istr, PDEFoam& pdefoam );	std::istream& operator>> ( std::istream& istr, PDEFoam& pdefoam );

	class PDEFoam : public TObject {	class PDEFoam : public TObject {
	protected:	protected:
	// COMPONENTS //	// COMPONENTS //

	skipping to change at line 127	skipping to change at line 137
	Double_t *fRvec; // [fDim] random number vector from r.n. g enerator fDim+1 maximum elements	Double_t *fRvec; // [fDim] random number vector from r.n. g enerator fDim+1 maximum elements
	//----------- Procedures	//----------- Procedures
	TRandom3 *fPseRan; // Pointer to user-defined generator of ps eudorandom numbers	TRandom3 *fPseRan; // Pointer to user-defined generator of ps eudorandom numbers
	//---------- working space for CELL exploration -------------	//---------- working space for CELL exploration -------------
	Double_t *fAlpha; // [fDim] Internal parameters of the hyper rectangle	Double_t *fAlpha; // [fDim] Internal parameters of the hyper rectangle
	// --------- PDE-Foam specific variables	// --------- PDE-Foam specific variables
	EFoamType fFoamType; // type of foam	EFoamType fFoamType; // type of foam
	Double_t *fXmin; // [fDim] minimum for variable transform	Double_t *fXmin; // [fDim] minimum for variable transform
	Double_t *fXmax; // [fDim] maximum for variable transform	Double_t *fXmax; // [fDim] maximum for variable transform
	UInt_t fNElements; // number of variables in every cell	UInt_t fNElements; // number of variables in every cell

	Bool_t fCutNmin; // true: activate cut on minimal number of e vents in cell
	UInt_t fNmin; // minimal number of events in cell to split cell	UInt_t fNmin; // minimal number of events in cell to split cell

	Bool_t fCutRMSmin; // true: peek cell with max. RMS for next sp	UInt_t fMaxDepth; // maximum depth of cell tree
	lit
	Double_t fRMSmin; // activate cut: minimal RMS in cell to spli
	t cell
	Float_t fVolFrac; // volume fraction (with respect to total ph ase space	Float_t fVolFrac; // volume fraction (with respect to total ph ase space

		Bool_t fFillFoamWithOrigWeights; // fill the foam with boost or orig.
		weights
		EDTSeparation fDTSeparation; // split cells according to decision tre
		e logic
		Bool_t fPeekMax; // peek up cell with max. driver integral fo
		r split
	PDEFoamDistr *fDistr; //! distribution of training events	PDEFoamDistr *fDistr; //! distribution of training events
	Timer *fTimer; // timer for graphical output	Timer *fTimer; // timer for graphical output
	TObjArray *fVariableNames;// collection of all variable names	TObjArray *fVariableNames;// collection of all variable names

	Int_t fSignalClass; // TODO: intermediate solution to keep IsSig
	nal() of Event working. TODO: remove IsSignal() from Event
	Int_t fBackgroundClass; // TODO: intermediate solution to keep IsSig
	nal() of Event working. TODO: remove IsSignal() from Event
	mutable MsgLogger* fLogger; //! message logger	mutable MsgLogger* fLogger; //! message logger

	MsgLogger& Log() const { return *fLogger; }

	/////////////////////////////////////////////////////////////////	/////////////////////////////////////////////////////////////////
	// METHODS //	// METHODS //
	/////////////////////////////////////////////////////////////////	/////////////////////////////////////////////////////////////////
	private:	private:

	Double_t Sqr(Double_t x) const { return x*x;} // Square function	// Square function (fastest implementation)
		template<typename T> T Sqr(T x) const { return x*x; }
		PDEFoamDistr* GetDistr() const { assert(fDistr); return fDistr; }

	protected:	protected:
	// ---------- TMVA console output	// ---------- TMVA console output

	void OutputGrow(Bool_t finished = false ); // nice TMVA console outpu t	void OutputGrow(Bool_t finished = false ); // nice TMVA console outpu t

	// ---------- Weighting functions for kernels	// ---------- Weighting functions for kernels


	Float_t WeightGaus(PDEFoamCell*, std::vector<Float_t>, UInt_t dim=0);	Float_t WeightGaus(PDEFoamCell*, std::vector<Float_t>&, UInt_t dim=0) ;


	Double_t WeightLinNeighbors( std::vector<Float_t> txvec, ECellValue c v,	Double_t WeightLinNeighbors( std::vector<Float_t> &txvec, ECellValue cv,
	Int_t dim1=-1, Int_t dim2=-1,	Int_t dim1=-1, Int_t dim2=-1,
	Bool_t TreatEmptyCells=kFALSE );	Bool_t TreatEmptyCells=kFALSE );

	// ---------- Foam build-up functions	// ---------- Foam build-up functions

	// Internal foam initialization functions	// Internal foam initialization functions

	void InitCells(Bool_t CreateCellElements); // Initialisation of all foam cells	void InitCells(); // Initialisation of all foam cel ls
	Int_t CellFill(Int_t, PDEFoamCell*);// Allocates new empty cell and r eturn its index	Int_t CellFill(Int_t, PDEFoamCell*);// Allocates new empty cell and r eturn its index
	void Explore(PDEFoamCell *Cell); // Exploration of the new cell, d etermine <wt>, wtMax etc.	void Explore(PDEFoamCell *Cell); // Exploration of the new cell, d etermine <wt>, wtMax etc.

		void DTExplore(PDEFoamCell *Cell); // Exploration of the new cell ac cording to decision tree logic
	void Varedu(Double_t [], Int_t&, Double_t&,Double_t&); // Determines the best edge, variace reduction	void Varedu(Double_t [], Int_t&, Double_t&,Double_t&); // Determines the best edge, variace reduction
	void MakeAlpha(); // Provides random point inside hyperre ctangle	void MakeAlpha(); // Provides random point inside hyperre ctangle
	void Grow(); // build up foam	void Grow(); // build up foam
	Long_t PeekMax(); // peek cell with max. driver integral	Long_t PeekMax(); // peek cell with max. driver integral

		Long_t PeekLast(); // peek last created cell
	Int_t Divide(PDEFoamCell *); // Divide iCell into two daughters; iCe ll retained, taged as inactive	Int_t Divide(PDEFoamCell *); // Divide iCell into two daughters; iCe ll retained, taged as inactive
	Double_t Eval(Double_t *xRand, Double_t &event_density); // evaluate distribution on point 'xRand'	Double_t Eval(Double_t *xRand, Double_t &event_density); // evaluate distribution on point 'xRand'

		Float_t GetSeparation(Float_t s, Float_t b); // calculate separation

	// ---------- Cell value access functions	// ---------- Cell value access functions

	// low level functions to access a certain cell value	// low level functions to access a certain cell value

	TVectorD* GetCellElements(std::vector<Float_t>); // return cell elements of cell with given coordinates
	Double_t GetCellElement(PDEFoamCell *cell, UInt_t i); // get Element 'i' in cell 'cell'	Double_t GetCellElement(PDEFoamCell *cell, UInt_t i); // get Element 'i' in cell 'cell'
	void SetCellElement(PDEFoamCell *cell, UInt_t i, Double_t value); // set Element 'i' in cell 'cell' to value 'value'	void SetCellElement(PDEFoamCell *cell, UInt_t i, Double_t value); // set Element 'i' in cell 'cell' to value 'value'

	// helper functions to access cell data	// helper functions to access cell data
	Double_t GetCellValue(PDEFoamCell*, ECellValue);	Double_t GetCellValue(PDEFoamCell*, ECellValue);

	// specific function used during evaluation; determines, whether a ce ll value is undefined	// specific function used during evaluation; determines, whether a ce ll value is undefined
	Bool_t CellValueIsUndefined( PDEFoamCell* );	Bool_t CellValueIsUndefined( PDEFoamCell* );

	// finds cell according to given event variables	// finds cell according to given event variables

	PDEFoamCell* FindCell(std::vector<Float_t>); //!	PDEFoamCell* FindCell(std::vector<Float_t>&); //!
	std::vector<TMVA::PDEFoamCell*> FindCells(std::vector<Float_t>); //!	std::vector<TMVA::PDEFoamCell*> FindCells(std::vector<Float_t>&); //!

	// find cells, which fit a given event vector	// find cells, which fit a given event vector

	void FindCellsRecursive(std::vector<Float_t>, PDEFoamCell*,	void FindCellsRecursive(std::vector<Float_t>&, PDEFoamCell*,
	std::vector<PDEFoamCell*> &);	std::vector<PDEFoamCell*> &);

	// calculates the mean/ mpv target values for a given event 'tvals'	// calculates the mean/ mpv target values for a given event 'tvals'

	std::vector<Float_t> GetCellTargets( std::vector<Float_t> tvals, ETar getSelection ts );	std::vector<Float_t> GetCellTargets( std::vector<Float_t> &tvals, ETa rgetSelection ts );
	// get number of events in cell during foam build-up	// get number of events in cell during foam build-up
	Double_t GetBuildUpCellEvents(PDEFoamCell* cell);	Double_t GetBuildUpCellEvents(PDEFoamCell* cell);


		PDEFoam(const PDEFoam&); // Copy Constructor NOT USED

	// ---------- Public functions ----------------------------------	// ---------- Public functions ----------------------------------
	public:	public:
	PDEFoam(); // Default constructor (used only by ROOT streamer)	PDEFoam(); // Default constructor (used only by ROOT streamer)
	PDEFoam(const TString&); // Principal user-defined constructor	PDEFoam(const TString&); // Principal user-defined constructor
	virtual ~PDEFoam(); // Default destructor	virtual ~PDEFoam(); // Default destructor

	PDEFoam(const PDEFoam&); // Copy Constructor NOT USED

	// ---------- Foam creation functions	// ---------- Foam creation functions

	void Init(); // initialize PDEFoamDistr	void Init(); // initialize PDEFoamDistr
	void FillBinarySearchTree( const Event* ev, Bool_t NoNegWeights=kFALS E );	void FillBinarySearchTree( const Event* ev, Bool_t NoNegWeights=kFALS E );

	void Create(Bool_t CreateCellElements=false); // build-up foam	void Create(); // build-up foam

	// function to fill created cell with given value	// function to fill created cell with given value
	void FillFoamCells(const Event* ev, Bool_t NoNegWeights=kFALSE);	void FillFoamCells(const Event* ev, Bool_t NoNegWeights=kFALSE);

	// functions to calc discriminators/ mean targets for every cell	// functions to calc discriminators/ mean targets for every cell
	// using filled cell values	// using filled cell values
	void CalcCellDiscr();	void CalcCellDiscr();
	void CalcCellTarget();	void CalcCellTarget();

	// init TObject pointer on cells	// init TObject pointer on cells
	void ResetCellElements(Bool_t allcells = false);	void ResetCellElements(Bool_t allcells = false);

	// ---------- Getters and Setters	// ---------- Getters and Setters


	void SetkDim(Int_t kDim); // Sets dimension of cubical space	void SetDim(Int_t kDim); // Sets dimension of cubical space
	void SetnCells(Long_t nCells){fNCells =nCells;} // Sets maximum numb er of cells	void SetnCells(Long_t nCells){fNCells =nCells;} // Sets maximum numb er of cells
	void SetnSampl(Long_t nSampl){fNSampl =nSampl;} // Sets no of MC eve nts in cell exploration	void SetnSampl(Long_t nSampl){fNSampl =nSampl;} // Sets no of MC eve nts in cell exploration
	void SetnBin(Int_t nBin){fNBin = nBin;} // Sets no of bins i n histogs in cell exploration	void SetnBin(Int_t nBin){fNBin = nBin;} // Sets no of bins i n histogs in cell exploration
	void SetEvPerBin(Int_t EvPerBin){fEvPerBin =EvPerBin;} // Sets max. n o. of effective events per bin	void SetEvPerBin(Int_t EvPerBin){fEvPerBin =EvPerBin;} // Sets max. n o. of effective events per bin
	void SetInhiDiv(Int_t, Int_t ); // Set inhibition of cell division al ong certain edge	void SetInhiDiv(Int_t, Int_t ); // Set inhibition of cell division al ong certain edge
	void SetNElements(UInt_t numb){fNElements = numb;} // init every cell element (TVectorD*)	void SetNElements(UInt_t numb){fNElements = numb;} // init every cell element (TVectorD*)

	void SetPDEFoamVolumeFraction(Double_t vfr){fVolFrac = vfr;} // set V	void SetVolumeFraction(Float_t vfr){fVolFrac = vfr;} // set VolFrac
	olFrac to PDEFoam
	void SetVolumeFraction(Double_t); // set VolFrac to PDEFoamDistr
	void SetFoamType(EFoamType ft); // set foam type	void SetFoamType(EFoamType ft); // set foam type

		void SetFillFoamWithOrigWeights(Bool_t new_val){fFillFoamWithOrigWeig
		hts=new_val;}
		void SetDTSeparation(EDTSeparation new_val){fDTSeparation=new_val;}
		void SetPeekMax(Bool_t new_val){ fPeekMax = new_val; }


	void SetSignalClass( Int_t cls ) { fSignalClass = cls; fDistr->Se	// coverity[ -tainted_data_return ]
	tSignalClass( cls ); } // TODO: intermediate solution to keep IsSignal() of
	Event working. TODO: remove IsSignal() from Event
	void SetBackgroundClass( Int_t cls ) { fBackgroundClass = cls; fDistr
	->SetBackgroundClass( cls ); } // TODO: intermediate solution to keep IsSig
	nal() of Event working. TODO: remove IsSignal() from Event

	Int_t GetTotDim() const {return fDim; } // Get total dimension	Int_t GetTotDim() const {return fDim; } // Get total dimension
	TString GetFoamName() const {return fName; } // Get name of foam	TString GetFoamName() const {return fName; } // Get name of foam
	UInt_t GetNElements() const {return fNElements; } // returns number of elements, saved on every cell	UInt_t GetNElements() const {return fNElements; } // returns number of elements, saved on every cell

	Double_t GetPDEFoamVolumeFraction() const {return fVolFrac;} // get V olFrac from PDEFoam	Float_t GetVolumeFraction() const {return fVolFrac;} // get VolFrac from PDEFoam
	EFoamType GetFoamType() const {return fFoamType;}; // get foam t ype	EFoamType GetFoamType() const {return fFoamType;}; // get foam t ype
	UInt_t GetNActiveCells() const {return fNoAct;}; // returns numbe r of active cells	UInt_t GetNActiveCells() const {return fNoAct;}; // returns numbe r of active cells
	UInt_t GetNInActiveCells() const {return GetNCells()-GetNActiveCell s();}; // returns number of not active cells	UInt_t GetNInActiveCells() const {return GetNCells()-GetNActiveCell s();}; // returns number of not active cells
	UInt_t GetNCells() const {return fNCells;}; // returns nu mber of cells	UInt_t GetNCells() const {return fNCells;}; // returns nu mber of cells
	PDEFoamCell* GetRootCell() const {return fCells[0];}; // get pointe r to root cell	PDEFoamCell* GetRootCell() const {return fCells[0];}; // get pointe r to root cell

	// Getters and Setters for user cut options	// Getters and Setters for user cut options

	void CutNmin(Bool_t cut ) { fCutNmin = cut; }
	Bool_t CutNmin() { return fCutNmin; }
	void CutRMSmin(Bool_t cut ) { fCutRMSmin = cut; }
	Bool_t CutRMSmin() { return fCutRMSmin; }
	void SetNmin(UInt_t val) { fNmin=val; }	void SetNmin(UInt_t val) { fNmin=val; }
	UInt_t GetNmin() { return fNmin; }	UInt_t GetNmin() { return fNmin; }

	void SetRMSmin(Double_t val) { fRMSmin=val; }	Bool_t GetFillFoamWithOrigWeights() const { return fFillFoamWithOri
	Double_t GetRMSmin() { return fRMSmin; }	gWeights; }
		void SetMaxDepth(UInt_t maxdepth) { fMaxDepth = maxdepth; }
		UInt_t GetMaxDepth() const { return fMaxDepth; }

	// Getters and Setters for foam boundaries	// Getters and Setters for foam boundaries
	void SetXmin(Int_t idim, Double_t wmin);	void SetXmin(Int_t idim, Double_t wmin);
	void SetXmax(Int_t idim, Double_t wmax);	void SetXmax(Int_t idim, Double_t wmax);

	Double_t GetXmin(Int_t idim){return fXmin[idim];}	Double_t GetXmin(Int_t idim) const {return fXmin[idim];}
	Double_t GetXmax(Int_t idim){return fXmax[idim];}	Double_t GetXmax(Int_t idim) const {return fXmax[idim];}

	// Getters and Setters for variable names	// Getters and Setters for variable names

	void AddVariableName(const char *s) { AddVariableName(new TObjString(	void AddVariableName(const char *s) { AddVariableName(new TObjString(
	s)); };	s)); }
	void AddVariableName(TObjString *s) { fVariableNames->Add(s); };	void AddVariableName(TObjString *s) { fVariableNames->Add(s); }
	TObjString* GetVariableName(Int_t idx) {return dynamic_cast<TObjStrin	TObjString* GetVariableName(Int_t idx) {return dynamic_cast<TObjStrin
	g*>(fVariableNames->At(idx));};	g*>(fVariableNames->At(idx));}

		// Delete the fDistr object, which contains the binary search
		// tree
		void DeleteBinarySearchTree();

	// ---------- Transformation functions for event variables into foam boundaries	// ---------- Transformation functions for event variables into foam boundaries
	// reason: foam allways has boundaries [0, 1]	// reason: foam allways has boundaries [0, 1]


	Float_t VarTransform(Int_t idim, Float_t x); // transform [xmin	Float_t VarTransform(Int_t idim, Float_t x) const; // transform [xmin
	, xmax] --> [0, 1]	, xmax] --> [0, 1]
	std::vector<Float_t> VarTransform(std::vector<Float_t> invec);	std::vector<Float_t> VarTransform(std::vector<Float_t> &invec) const;
	Float_t VarTransformInvers(Int_t idim, Float_t x); // transform [0, 1	Float_t VarTransformInvers(Int_t idim, Float_t x) const; // transform
	] --> [xmin, xmax]	[0, 1] --> [xmin, xmax]
	std::vector<Float_t> VarTransformInvers(std::vector<Float_t> invec);	std::vector<Float_t> VarTransformInvers(std::vector<Float_t> &invec)
		const;

	// ---------- Debug functions	// ---------- Debug functions

	void CheckAll(Int_t); // Checks correctness of the entire data s tructure in the FOAM object	void CheckAll(Int_t); // Checks correctness of the entire data s tructure in the FOAM object

		void PrintCell(Long_t iCell=0); // Print content of cell
	void PrintCells(); // Prints content of all cells	void PrintCells(); // Prints content of all cells
	void CheckCells(Bool_t remove_empty_cells=false); // check all cells with respect to critical values	void CheckCells(Bool_t remove_empty_cells=false); // check all cells with respect to critical values
	void RemoveEmptyCell(Int_t iCell); // removes iCell if its volume is zero	void RemoveEmptyCell(Int_t iCell); // removes iCell if its volume is zero
	void PrintCellElements(); // print all cells with its el ements	void PrintCellElements(); // print all cells with its el ements


		// Message logger
		MsgLogger& Log() const { return *fLogger; }

	// ---------- Foam output	// ---------- Foam output

	friend std::ostream& operator<< ( std::ostream& os, const PDEFoam& pd efoam );	friend std::ostream& operator<< ( std::ostream& os, const PDEFoam& pd efoam );
	friend std::istream& operator>> ( std::istream& istr, PDEFoam& pd efoam );	friend std::istream& operator>> ( std::istream& istr, PDEFoam& pd efoam );

	void ReadStream(istream &); // read foam from stream	void ReadStream(istream &); // read foam from stream
	void PrintStream(ostream &) const; // write foam from stream	void PrintStream(ostream &) const; // write foam from stream
	void ReadXML( void* parent ); // read foam variables from xml	void ReadXML( void* parent ); // read foam variables from xml
	void AddXMLTo( void* parent ); // write foam variables to xml	void AddXMLTo( void* parent ); // write foam variables to xml

	// ---------- Foam projection methods	// ---------- Foam projection methods

	// project foam to two-dimensional histogram	// project foam to two-dimensional histogram

	TH2D* Project2(Int_t idim1, Int_t idim2, const char *opt="nev",	TH2D* Project2(Int_t idim1, Int_t idim2, const char *opt="cell_value"
	const char *ker="kNone", UInt_t maxbins=0);	,
		const char *ker="kNone", UInt_t maxbins=50);

	// helper function for Project2()	// helper function for Project2()
	Double_t GetProjectionCellValue( PDEFoamCell* cell,	Double_t GetProjectionCellValue( PDEFoamCell* cell,
	Int_t idim1, Int_t idim2, ECellValue cv );	Int_t idim1, Int_t idim2, ECellValue cv );

	// Project one-dimensional foam to a 1-dim histogram	// Project one-dimensional foam to a 1-dim histogram
	TH1D* Draw1Dim(const char *opt, Int_t nbin);	TH1D* Draw1Dim(const char *opt, Int_t nbin);

	// Generates C++ code (root macro) for drawing foam with boxes (only 2-dim!)	// Generates C++ code (root macro) for drawing foam with boxes (only 2-dim!)

	void RootPlot2dim( const TString& filename, std::string what,	void RootPlot2dim( const TString& filename, TString opt,
	Bool_t CreateCanvas = kTRUE, Bool_t colors = kTRUE ,	Bool_t CreateCanvas = kTRUE, Bool_t colors = kTRUE ,
	Bool_t log_colors = kFALSE );	Bool_t log_colors = kFALSE );

	// ---------- Foam evaluation functions	// ---------- Foam evaluation functions

	// get cell value for a given event	// get cell value for a given event

	Double_t GetCellValue(std::vector<Float_t>, ECellValue);	Double_t GetCellValue(std::vector<Float_t>&, ECellValue);

	// helper functions to access cell data with kernel	// helper functions to access cell data with kernel

	Double_t GetCellDiscr(std::vector<Float_t> xvec, EKernel kernel=kNone	Double_t GetCellDiscr(std::vector<Float_t> &xvec, EKernel kernel=kNon
	);	e);
	Double_t GetCellDensity(std::vector<Float_t> xvec, EKernel kernel=kNo	Double_t GetCellDensity(std::vector<Float_t> &xvec, EKernel kernel=kN
	ne);	one);

	// calc mean cell value of neighbor cells	// calc mean cell value of neighbor cells

	Double_t GetAverageNeighborsValue(std::vector<Float_t> txvec, ECellVa lue cv);	Double_t GetAverageNeighborsValue(std::vector<Float_t> &txvec, ECellV alue cv);

	// returns regression value (mono target regression)	// returns regression value (mono target regression)

	Double_t GetCellRegValue0(std::vector<Float_t>, EKernel kernel=kNone) ;	Double_t GetCellRegValue0(std::vector<Float_t>&, EKernel kernel=kNone );

	// returns regression value i, given all variables (multi target regr ession)	// returns regression value i, given all variables (multi target regr ession)

	std::vector<Float_t> GetProjectedRegValue(std::vector<Float_t> vals, EKernel kernel=kNone, ETargetSelection ts=kMean);	std::vector<Float_t> GetProjectedRegValue(std::vector<Float_t> &vals, EKernel kernel=kNone, ETargetSelection ts=kMean);

	// ---------- ROOT class definition	// ---------- ROOT class definition

	ClassDef(PDEFoam,3)	ClassDef(PDEFoam,5) // Tree of PDEFoamCells
	}; // end of PDEFoam	}; // end of PDEFoam

	} // namespace TMVA	} // namespace TMVA

	// ---------- Inline functions	// ---------- Inline functions

	//_____________________________________________________________________	//_____________________________________________________________________

	inline Float_t TMVA::PDEFoam::VarTransform(Int_t idim, Float_t x)	inline Float_t TMVA::PDEFoam::VarTransform(Int_t idim, Float_t x) const
	{	{
	// transform variable x from [xmin, xmax] --> [0, 1]	// transform variable x from [xmin, xmax] --> [0, 1]
	return (x-fXmin[idim])/(fXmax[idim]-fXmin[idim]);	return (x-fXmin[idim])/(fXmax[idim]-fXmin[idim]);
	}	}

	//_____________________________________________________________________	//_____________________________________________________________________

	inline std::vector<Float_t> TMVA::PDEFoam::VarTransform(std::vector<Float_t > invec)	inline std::vector<Float_t> TMVA::PDEFoam::VarTransform(std::vector<Float_t > &invec) const
	{	{
	// transform vector invec from [xmin, xmax] --> [0, 1]	// transform vector invec from [xmin, xmax] --> [0, 1]
	std::vector<Float_t> outvec;	std::vector<Float_t> outvec;
	for(UInt_t i=0; i<invec.size(); i++)	for(UInt_t i=0; i<invec.size(); i++)
	outvec.push_back(VarTransform(i, invec.at(i)));	outvec.push_back(VarTransform(i, invec.at(i)));
	return outvec;	return outvec;
	}	}

	//_____________________________________________________________________	//_____________________________________________________________________

	inline Float_t TMVA::PDEFoam::VarTransformInvers(Int_t idim, Float_t x)	inline Float_t TMVA::PDEFoam::VarTransformInvers(Int_t idim, Float_t x) con st
	{	{
	// transform variable x from [0, 1] --> [xmin, xmax]	// transform variable x from [0, 1] --> [xmin, xmax]
	return x*(fXmax[idim]-fXmin[idim]) + fXmin[idim];	return x*(fXmax[idim]-fXmin[idim]) + fXmin[idim];
	}	}

	//_____________________________________________________________________	//_____________________________________________________________________

	inline std::vector<Float_t> TMVA::PDEFoam::VarTransformInvers(std::vector<F loat_t> invec)	inline std::vector<Float_t> TMVA::PDEFoam::VarTransformInvers(std::vector<F loat_t> &invec) const
	{	{
	// transform vector invec from [0, 1] --> [xmin, xmax]	// transform vector invec from [0, 1] --> [xmin, xmax]
	std::vector<Float_t> outvec;	std::vector<Float_t> outvec;
	for(UInt_t i=0; i<invec.size(); i++)	for(UInt_t i=0; i<invec.size(); i++)
	outvec.push_back(VarTransformInvers(i, invec.at(i)));	outvec.push_back(VarTransformInvers(i, invec.at(i)));
	return outvec;	return outvec;
	}	}

	#endif	#endif

End of changes. 47 change blocks.
	73 lines changed or deleted	89 lines changed or added

	PDEFoamDistr.h	PDEFoamDistr.h

	skipping to change at line 49	skipping to change at line 49
	#ifndef ROOT_TH2D	#ifndef ROOT_TH2D
	#include "TH2D.h"	#include "TH2D.h"
	#endif	#endif

	#ifndef ROOT_TMVA_BinarySearchTree	#ifndef ROOT_TMVA_BinarySearchTree
	#include "TMVA/BinarySearchTree.h"	#include "TMVA/BinarySearchTree.h"
	#endif	#endif
	#ifndef ROOT_TMVA_Event	#ifndef ROOT_TMVA_Event
	#include "TMVA/Event.h"	#include "TMVA/Event.h"
	#endif	#endif

		#ifndef ROOT_TMVA_PDEFoam
		#include "TMVA/PDEFoam.h"
		#endif
	#ifndef ROOT_TMVA_PDEFoamCell	#ifndef ROOT_TMVA_PDEFoamCell
	#include "TMVA/PDEFoamCell.h"	#include "TMVA/PDEFoamCell.h"
	#endif	#endif

		#ifndef ROOT_TMVA_MsgLogger
		#include "TMVA/MsgLogger.h"
		#endif

	namespace TMVA {	namespace TMVA {

	enum EFoamType { kSeparate, kDiscr, kMonoTarget, kMultiTarget };

	// options for filling density (used in Density() to build up foam)	// options for filling density (used in Density() to build up foam)
	// kEVENT_DENSITY : use event density for foam buildup	// kEVENT_DENSITY : use event density for foam buildup
	// kDISCRIMINATOR : use N_sig/(N_sig + N_bg) for foam buildup	// kDISCRIMINATOR : use N_sig/(N_sig + N_bg) for foam buildup
	// kTARGET : use GetTarget(0) for foam build up	// kTARGET : use GetTarget(0) for foam build up
	enum TDensityCalc { kEVENT_DENSITY, kDISCRIMINATOR, kTARGET };	enum TDensityCalc { kEVENT_DENSITY, kDISCRIMINATOR, kTARGET };
	}	}

	namespace TMVA {	namespace TMVA {

	// class definition of underlying density	// class definition of underlying density
	class PDEFoamDistr : public ::TObject {	class PDEFoamDistr : public ::TObject {

	private:	private:

	Int_t fDim; // number of dimensions	const PDEFoam *fPDEFoam; // PDEFoam to refer to
	Float_t *fXmin; //[fDim] minimal value of phase space in al
	l dimension
	Float_t *fXmax; //[fDim] maximal value of phase space in al
	l dimension
	Float_t fVolFrac; // volume fraction (with respect to total p
	hase space
	BinarySearchTree *fBst; // Binary tree to find events within a volu me	BinarySearchTree *fBst; // Binary tree to find events within a volu me
	TDensityCalc fDensityCalc;// method of density calculation	TDensityCalc fDensityCalc;// method of density calculation

	protected:	protected:

	UInt_t fSignalClass; // TODO: intermediate solution to keep IsSi
	gnal() of Event working. TODO: remove IsSignal() from Event
	Int_t fBackgroundClass; // TODO: intermediate solution to keep IsSig
	nal() of Event working. TODO: remove IsSignal() from Event

	mutable MsgLogger* fLogger; //! message logger	mutable MsgLogger* fLogger; //! message logger
	MsgLogger& Log() const { return *fLogger; }	MsgLogger& Log() const { return *fLogger; }

	public:	public:
	PDEFoamDistr();	PDEFoamDistr();
	PDEFoamDistr(const PDEFoamDistr&);	PDEFoamDistr(const PDEFoamDistr&);
	virtual ~PDEFoamDistr();	virtual ~PDEFoamDistr();


	// Getter and setter for VolFrac option
	void SetVolumeFraction(Float_t vfr){fVolFrac=vfr; return;}
	Float_t GetVolumeFraction(){return fVolFrac;}

	// set foam dimension (mandatory before foam build-up!)
	void SetDim(Int_t idim);

	// set foam boundaries
	void SetXmin(Int_t idim,Float_t wmin){fXmin[idim]=wmin; return;}
	void SetXmax(Int_t idim,Float_t wmax){fXmax[idim]=wmax; return;}

	// transformation functions for event variable into foam boundaries
	// reason: foam allways has boundaries [0, 1]
	Float_t VarTransform(Int_t idim, Float_t x){ // transform [xmi
	n, xmax] --> [0, 1]
	Float_t b=fXmax[idim]-fXmin[idim];
	return (x-fXmin[idim])/b;
	}
	Float_t VarTransformInvers(Int_t idim, Float_t x){ // transform [0,
	1] --> [xmin, xmax]
	Float_t b=fXmax[idim]-fXmin[idim];
	return x*b + fXmin[idim];
	}

	// density build-up functions	// density build-up functions

	void Initialize(Int_t ndim = 2);	void Initialize(); // create and initialize binary search tree
	void FillBinarySearchTree( const Event* ev, EFoamType ft, Bool_t NoNe gWeights=kFALSE );	void FillBinarySearchTree( const Event* ev, EFoamType ft, Bool_t NoNe gWeights=kFALSE );

	// main function used by PDEFoam	// main function used by PDEFoam
	// returns density at a given point by range searching in BST	// returns density at a given point by range searching in BST
	Double_t Density(Double_t *Xarg, Double_t &event_density);	Double_t Density(Double_t *Xarg, Double_t &event_density);


		// Return fDim histograms with signal and bg events
		void FillHist(PDEFoamCell* cell, std::vector<TH1F*>&, std::vector<TH1
		F*>&,
		std::vector<TH1F>&, std::vector<TH1F>&);

		// Getter and setter for the fPDEFoam pointer
		void SetPDEFoam(const PDEFoam *foam){ fPDEFoam = foam; }
		const PDEFoam* GetPDEFoam() const { return fPDEFoam; };

	// Getters and setters for foam filling method	// Getters and setters for foam filling method
	void SetDensityCalc( TDensityCalc dc ){ fDensityCalc = dc; };	void SetDensityCalc( TDensityCalc dc ){ fDensityCalc = dc; };
	Bool_t FillDiscriminator(){ return fDensityCalc == kDISCRIMINATOR; }	Bool_t FillDiscriminator(){ return fDensityCalc == kDISCRIMINATOR; }
	Bool_t FillTarget0() { return fDensityCalc == kTARGET; }	Bool_t FillTarget0() { return fDensityCalc == kTARGET; }
	Bool_t FillEventDensity() { return fDensityCalc == kEVENT_DENSITY; }	Bool_t FillEventDensity() { return fDensityCalc == kEVENT_DENSITY; }


	void SetSignalClass( Int_t cls ) { fSignalClass = cls; } // TODO	ClassDef(PDEFoamDistr,3) //Class for Event density
	: intermediate solution to keep IsSignal() of Event working. TODO: remove I
	sSignal() from Event
	void SetBackgroundClass( Int_t cls ) { fBackgroundClass = cls; } //
	TODO: intermediate solution to keep IsSignal() of Event working. TODO: remo
	ve IsSignal() from Event

	ClassDef(PDEFoamDistr,2) //Class for Event density
	}; //end of PDEFoamDistr	}; //end of PDEFoamDistr

	} // namespace TMVA	} // namespace TMVA

	#endif	#endif

End of changes. 9 change blocks.
	47 lines changed or deleted	18 lines changed or added

	PDEFoamVect.h	PDEFoamVect.h

	skipping to change at line 34	skipping to change at line 34
	* (http://tmva.sourceforge.net/LICENSE) *	* (http://tmva.sourceforge.net/LICENSE) *
	************************************************************************ ******/	************************************************************************ ******/

	#ifndef ROOT_TMVA_PDEFoamVect	#ifndef ROOT_TMVA_PDEFoamVect
	#define ROOT_TMVA_PDEFoamVect	#define ROOT_TMVA_PDEFoamVect

	#ifndef ROOT_TObject	#ifndef ROOT_TObject
	#include "TObject.h"	#include "TObject.h"
	#endif	#endif


	#ifndef ROOT_TMVA_MsgLogger
	#include "TMVA/MsgLogger.h"
	#endif

	namespace TMVA {	namespace TMVA {

	class PDEFoamVect : public TObject {	class PDEFoamVect : public TObject {

	private:	private:
	Int_t fDim; // Dimension	Int_t fDim; // Dimension
	Double_t *fCoords; // [fDim] Coordinates	Double_t *fCoords; // [fDim] Coordinates


	protected:
	static MsgLogger* fgLogger; //! message logger, s
	tatic because there is a huge number of vectors...
	MsgLogger& Log() const { return *fgLogger; }

	public:	public:
	// constructor	// constructor
	PDEFoamVect(); // Constructor	PDEFoamVect(); // Constructor
	PDEFoamVect(Int_t); // USER Constructor	PDEFoamVect(Int_t); // USER Constructor
	PDEFoamVect(const PDEFoamVect &); // Copy constructor	PDEFoamVect(const PDEFoamVect &); // Copy constructor
	virtual ~PDEFoamVect(); // Destructor	virtual ~PDEFoamVect(); // Destructor

	///////////////////////////////////////////////////////////////////// /////////	///////////////////////////////////////////////////////////////////// /////////
	// Overloading operators //	// Overloading operators //
	///////////////////////////////////////////////////////////////////// /////////	///////////////////////////////////////////////////////////////////// /////////

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

	PdfFuncMathCore.h	PdfFuncMathCore.h

	// @(#)root/mathcore:$Id: PdfFuncMathCore.h 34095 2010-06-24 07:31:19Z mone ta $	// @(#)root/mathcore:$Id: PdfFuncMathCore.h 37441 2010-12-09 16:27:54Z mone ta $
	// Authors: Andras Zsenei & Lorenzo Moneta 06/2005	// Authors: Andras Zsenei & Lorenzo Moneta 06/2005

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2005 , LCG ROOT MathLib Team *	* Copyright (c) 2005 , LCG ROOT MathLib Team *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	/**	/**

	skipping to change at line 99	skipping to change at line 99
	Mathworld</A>.	Mathworld</A>.

	@ingroup PdfFunc	@ingroup PdfFunc

	*/	*/

	double binomial_pdf(unsigned int k, double p, unsigned int n);	double binomial_pdf(unsigned int k, double p, unsigned int n);

	/**	/**


		Probability density function of the negative binomial distribution.

		\f[ p(k) = \frac{(k+n-1)!}{k! (n-1)!} p^{n} (1-p)^{k} \f]

		For detailed description see
		<A HREF="http://mathworld.wolfram.com/NegativeBinomialDistribution.html">
		Mathworld</A> (where $k \to x$ and $n \to r$).
		The distribution in <A HREF="http://en.wikipedia.org/wiki/Negative_binomi
		al_distribution">
		Wikipedia</A> is defined with a $p$ corresponding to $1-p$ in this case.

		@ingroup PdfFunc

		*/

		double negative_binomial_pdf(unsigned int k, double p, double n);

		/**

	Probability density function of Breit-Wigner distribution, which is simil ar, just	Probability density function of Breit-Wigner distribution, which is simil ar, just
	a different definition of the parameters, to the Cauchy distribution	a different definition of the parameters, to the Cauchy distribution
	(see #cauchy_pdf )	(see #cauchy_pdf )

	\f[ p(x) = \frac{1}{\pi} \frac{\frac{1}{2} \Gamma}{x^2 + (\frac{1}{2} \Ga mma)^2} \f]	\f[ p(x) = \frac{1}{\pi} \frac{\frac{1}{2} \Gamma}{x^2 + (\frac{1}{2} \Ga mma)^2} \f]

	@ingroup PdfFunc	@ingroup PdfFunc

	*/	*/


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

	ProbFuncMathCore.h	ProbFuncMathCore.h

	// @(#)root/mathcore:$Id: ProbFuncMathCore.h 34095 2010-06-24 07:31:19Z mon eta $	// @(#)root/mathcore:$Id: ProbFuncMathCore.h 37441 2010-12-09 16:27:54Z mon eta $
	// Authors: L. Moneta, A. Zsenei 06/2005	// Authors: L. Moneta, A. Zsenei 06/2005

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2005 , LCG ROOT MathLib Team *	* Copyright (c) 2005 , LCG ROOT MathLib Team *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	#if defined(__CINT__) && !defined(__MAKECINT__)	#if defined(__CINT__) && !defined(__MAKECINT__)

	skipping to change at line 522	skipping to change at line 522

	Cumulative distribution function of the Binomial distribution	Cumulative distribution function of the Binomial distribution
	Lower tail of the integral of the #binomial_pdf	Lower tail of the integral of the #binomial_pdf

	@ingroup ProbFunc	@ingroup ProbFunc

	*/	*/

	double binomial_cdf(unsigned int k, double p, unsigned int n);	double binomial_cdf(unsigned int k, double p, unsigned int n);


		/**

		Complement of the cumulative distribution function of the Negative Binom
		ial distribution.
		Upper tail of the integral of the #negative_binomial_pdf

		@ingroup ProbFunc

		*/

		double negative_binomial_cdf_c(unsigned int k, double p, double n);

		/**

		Cumulative distribution function of the Negative Binomial distribution
		Lower tail of the integral of the #negative_binomial_pdf

		@ingroup ProbFunc

		*/

		double negative_binomial_cdf(unsigned int k, double p, double n);

	#ifdef HAVE_OLD_STAT_FUNC	#ifdef HAVE_OLD_STAT_FUNC

	/** @name Backward compatible MathCore CDF functions */	/** @name Backward compatible MathCore CDF functions */

	inline double breitwigner_prob(double x, double gamma, double x0 = 0) {	inline double breitwigner_prob(double x, double gamma, double x0 = 0) {
	return breitwigner_cdf_c(x,gamma,x0);	return breitwigner_cdf_c(x,gamma,x0);
	}	}
	inline double breitwigner_quant(double x, double gamma, double x0 = 0) {	inline double breitwigner_quant(double x, double gamma, double x0 = 0) {
	return breitwigner_cdf(x,gamma,x0);	return breitwigner_cdf(x,gamma,x0);
	}	}

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

	ProfileLikelihoodTestStat.h	ProfileLikelihoodTestStat.h

	// @(#)root/roostats:$Id: ProfileLikelihoodTestStat.h 34264 2010-07-01 09:1 3:18Z moneta $	// @(#)root/roostats:$Id: ProfileLikelihoodTestStat.h 36602 2010-11-11 16:5 2:13Z moneta $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, 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 ROOSTATS_ProfileLikelihoodTestStat	#ifndef ROOSTATS_ProfileLikelihoodTestStat

	skipping to change at line 43	skipping to change at line 43
	#endif	#endif

	#include <vector>	#include <vector>

	#include "RooStats/RooStatsUtils.h"	#include "RooStats/RooStatsUtils.h"

	//#include "RooStats/DistributionCreator.h"	//#include "RooStats/DistributionCreator.h"
	#include "RooStats/SamplingDistribution.h"	#include "RooStats/SamplingDistribution.h"
	#include "RooStats/TestStatistic.h"	#include "RooStats/TestStatistic.h"


		#include "RooStats/RooStatsUtils.h"

	#include "RooRealVar.h"	#include "RooRealVar.h"
	#include "RooProfileLL.h"	#include "RooProfileLL.h"
	#include "RooNLLVar.h"	#include "RooNLLVar.h"

	#include "RooMinuit.h"	#include "RooMinuit.h"

	namespace RooStats {	namespace RooStats {

	class ProfileLikelihoodTestStat : public TestStatistic{	class ProfileLikelihoodTestStat : public TestStatistic{

	public:	public:

		ProfileLikelihoodTestStat() {
		// Proof constructor. Do not use.
		fPdf = 0;
		fProfile = 0;
		fNll = 0;
		fCachedBestFitParams = 0;
		fLastData = 0;
		}
	ProfileLikelihoodTestStat(RooAbsPdf& pdf) {	ProfileLikelihoodTestStat(RooAbsPdf& pdf) {
	fPdf = &pdf;	fPdf = &pdf;
	fProfile = 0;	fProfile = 0;
	fNll = 0;	fNll = 0;
	fCachedBestFitParams = 0;	fCachedBestFitParams = 0;
	fLastData = 0;	fLastData = 0;
	}	}
	virtual ~ProfileLikelihoodTestStat() {	virtual ~ProfileLikelihoodTestStat() {
	// delete fRand;	// delete fRand;
	// delete fTestStatistic;	// delete fTestStatistic;
	if(fProfile) delete fProfile;	if(fProfile) delete fProfile;
	if(fNll) delete fNll;	if(fNll) delete fNll;
	if(fCachedBestFitParams) delete fCachedBestFitParams;	if(fCachedBestFitParams) delete fCachedBestFitParams;
	}	}

	// Main interface to evaluate the test statistic on a dataset	// Main interface to evaluate the test statistic on a dataset
	virtual Double_t Evaluate(RooAbsData& data, RooArgSet& paramsOfInteres t) {	virtual Double_t Evaluate(RooAbsData& data, RooArgSet& paramsOfInteres t) {
	if (!&data) {	if (!&data) {
	cout << "problem with data" << endl;	cout << "problem with data" << endl;

		return 0 ;
	}	}

	RooFit::MsgLevel msglevel = RooMsgService::instance().globalKillBelo w();	RooFit::MsgLevel msglevel = RooMsgService::instance().globalKillBelo w();
	RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL);	RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL);

	// simple	// simple
	RooAbsReal* nll = fPdf->createNLL(data, RooFit::CloneData(kFALSE));	RooAbsReal* nll = fPdf->createNLL(data, RooFit::CloneData(kFALSE));
	RooAbsReal* profile = nll->createProfile(paramsOfInterest);	RooAbsReal* profile = nll->createProfile(paramsOfInterest);

		// make sure we set the variables attached to this nll
		RooArgSet* attachedSet = nll->getVariables();
		*attachedSet = paramsOfInterest;
	double ret = profile->getVal();	double ret = profile->getVal();
	// paramsOfInterest.Print("v");	// paramsOfInterest.Print("v");

		delete attachedSet;
	delete nll;	delete nll;
	nll = 0;	nll = 0;
	delete profile;	delete profile;
	RooMsgService::instance().setGlobalKillBelow(msglevel);	RooMsgService::instance().setGlobalKillBelow(msglevel);
	// cout << "ret = " << ret << endl;	// cout << "ret = " << ret << endl;


		// return here and forget about the following code
	return ret;	return ret;

	// OLD version with some handling for local minima	// OLD version with some handling for local minima

		// (not used right now)

	bool needToRebuild = true; // try to avoid rebuilding if possible	bool needToRebuild = true; // try to avoid rebuilding if possible

	if (fLastData == &data) // simple pointer comparison for now (note NLL makes COPY of data)	if (fLastData == &data) // simple pointer comparison for now (note NLL makes COPY of data)
	needToRebuild = false;	needToRebuild = false;
	else fLastData = &data; // keep a copy of pointer to original data	else fLastData = &data; // keep a copy of pointer to original data

	// pointer comparison causing problems. See multiple datasets wit h same value of pointer	// pointer comparison causing problems. See multiple datasets wit h same value of pointer
	// but actually a new dataset	// but actually a new dataset
	needToRebuild = true;	needToRebuild = true;

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

	QuantFuncMathCore.h	QuantFuncMathCore.h

	// @(#)root/mathcore:$Id: QuantFuncMathCore.h 34095 2010-06-24 07:31:19Z mo neta $	// @(#)root/mathcore:$Id: QuantFuncMathCore.h 36536 2010-11-08 15:03:24Z mo neta $
	// Authors: L. Moneta, A. Zsenei 08/2005	// Authors: L. Moneta, A. Zsenei 08/2005

	// Authors: Andras Zsenei & Lorenzo Moneta 08/2005	// Authors: Andras Zsenei & Lorenzo Moneta 08/2005

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2005 , LCG ROOT MathLib Team *	* Copyright (c) 2005 , LCG ROOT MathLib Team *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	skipping to change at line 26	skipping to change at line 26
	#include "../lib/libMathCore.so"	#include "../lib/libMathCore.so"
	#else	#else
	#include "../bin/libMathCore.dll"	#include "../bin/libMathCore.dll"
	#endif	#endif

	#else	#else

	#ifndef ROOT_Math_QuantFuncMathCore	#ifndef ROOT_Math_QuantFuncMathCore
	#define ROOT_Math_QuantFuncMathCore	#define ROOT_Math_QuantFuncMathCore


	// required for R__HAS_MATHMORE
	#ifndef ROOT_RConfigure
	#include "RConfigure.h"
	#endif

	namespace ROOT {	namespace ROOT {
	namespace Math {	namespace Math {

	/** @defgroup QuantFunc Quantile Functions	/** @defgroup QuantFunc Quantile Functions
	* @ingroup StatFunc	* @ingroup StatFunc
	*	*
	* Inverse functions of the cumulative distribution functions	* Inverse functions of the cumulative distribution functions
	* and the inverse of the complement of the cumulative distribution func tions	* and the inverse of the complement of the cumulative distribution func tions
	* for various distributions.	* for various distributions.
	* The functions with the extension <em>_quantile</em> calculate the	* The functions with the extension <em>_quantile</em> calculate the

	skipping to change at line 180	skipping to change at line 175
	<A HREF="http://mathworld.wolfram.com/Chi-SquaredDistribution.html">	<A HREF="http://mathworld.wolfram.com/Chi-SquaredDistribution.html">
	Mathworld</A>. It is implemented using the inverse of the incomplete complement gamma function, using	Mathworld</A>. It is implemented using the inverse of the incomplete complement gamma function, using
	the function igami from <A HREF="http://www.netlib.org/cephes">Cephes </A>.	the function igami from <A HREF="http://www.netlib.org/cephes">Cephes </A>.

	@ingroup QuantFunc	@ingroup QuantFunc

	*/	*/

	double chisquared_quantile_c(double z, double r);	double chisquared_quantile_c(double z, double r);


	#ifndef R__HAS_MATHMORE

	/**	/**

	Inverse (\f$D^{-1}(z)\f$) of the cumulative distribution	Inverse (\f$D^{-1}(z)\f$) of the cumulative distribution
	function of the lower tail of the \f$\chi^2\f$ distribution	function of the lower tail of the \f$\chi^2\f$ distribution
	with \f$r\f$ degrees of freedom (#chisquared_cdf). For detailed descr iption see	with \f$r\f$ degrees of freedom (#chisquared_cdf). For detailed descr iption see
	<A HREF="http://mathworld.wolfram.com/Chi-SquaredDistribution.html">	<A HREF="http://mathworld.wolfram.com/Chi-SquaredDistribution.html">
	Mathworld</A>.	Mathworld</A>.
	It is implemented using chisquared_quantile_c, therefore is not very precise for small z.	It is implemented using chisquared_quantile_c, therefore is not very precise for small z.

	It is reccomended to use the MathMore function implemented using GSL	It is reccomended to use the MathMore function (ROOT::MathMore::chisq uared_quantile )implemented using GSL


	@ingroup QuantFunc_def_in_MathMore	@ingroup QuantFunc

	*/	*/

	double chisquared_quantile(double z, double r);	double chisquared_quantile(double z, double r);


	#endif

	/**	/**

	Inverse (\f$D^{-1}(z)\f$) of the cumulative distribution	Inverse (\f$D^{-1}(z)\f$) of the cumulative distribution
	function of the upper tail of the exponential distribution	function of the upper tail of the exponential distribution
	(#exponential_cdf_c). For detailed description see	(#exponential_cdf_c). For detailed description see
	<A HREF="http://mathworld.wolfram.com/ExponentialDistribution.html">	<A HREF="http://mathworld.wolfram.com/ExponentialDistribution.html">
	Mathworld</A>.	Mathworld</A>.

	@ingroup QuantFunc	@ingroup QuantFunc


	skipping to change at line 275	skipping to change at line 266
	<A HREF="http://www.gnu.org/software/gsl/manual/gsl-ref_19.html#SEC30 0">GSL</A>.	<A HREF="http://www.gnu.org/software/gsl/manual/gsl-ref_19.html#SEC30 0">GSL</A>.
	It is implemented using the function igami taken	It is implemented using the function igami taken
	from <A HREF="http://www.netlib.org/cephes">Cephes</A>.	from <A HREF="http://www.netlib.org/cephes">Cephes</A>.

	@ingroup QuantFunc	@ingroup QuantFunc

	*/	*/

	double gamma_quantile_c(double z, double alpha, double theta);	double gamma_quantile_c(double z, double alpha, double theta);


	#ifndef R__HAS_MATHMORE

	/**	/**

	Inverse (\f$D^{-1}(z)\f$) of the cumulative distribution	Inverse (\f$D^{-1}(z)\f$) of the cumulative distribution
	function of the lower tail of the gamma distribution	function of the lower tail of the gamma distribution
	(#gamma_cdf). For detailed description see	(#gamma_cdf). For detailed description see
	<A HREF="http://mathworld.wolfram.com/GammaDistribution.html">	<A HREF="http://mathworld.wolfram.com/GammaDistribution.html">
	Mathworld</A>.	Mathworld</A>.
	It is implemented using chisquared_quantile_c, therefore is not very precise for small z.	It is implemented using chisquared_quantile_c, therefore is not very precise for small z.

	It is reccomended to use the MathMore function implemented using GSL	For this special cases it is reccomended to use the MathMore function
		ROOT::MathMore::gamma_quantile
		implemented using GSL


	@ingroup QuantFunc_def_in_MathMore	@ingroup QuantFunc

	*/	*/

	double gamma_quantile(double z, double alpha, double theta);	double gamma_quantile(double z, double alpha, double theta);


	#endif

	/**	/**

	Inverse (\f$D^{-1}(z)\f$) of the cumulative distribution	Inverse (\f$D^{-1}(z)\f$) of the cumulative distribution
	function of the upper tail of the normal (Gaussian) distribution	function of the upper tail of the normal (Gaussian) distribution
	(#gaussian_cdf_c). For detailed description see	(#gaussian_cdf_c). For detailed description see
	<A HREF="http://mathworld.wolfram.com/NormalDistribution.html">	<A HREF="http://mathworld.wolfram.com/NormalDistribution.html">
	Mathworld</A>. It can also be evaluated using #normal_quantile_c whic h will	Mathworld</A>. It can also be evaluated using #normal_quantile_c whic h will
	call the same implementation.	call the same implementation.

	@ingroup QuantFunc	@ingroup QuantFunc

	skipping to change at line 567	skipping to change at line 555

	inline double gamma_prob_inv(double x, double alpha, double theta) {	inline double gamma_prob_inv(double x, double alpha, double theta) {
	return gamma_quantile_c (x, alpha, theta );	return gamma_quantile_c (x, alpha, theta );
	}	}

	#endif	#endif

	} // namespace Math	} // namespace Math
	} // namespace ROOT	} // namespace ROOT


	#endif // ROOT_Math_QuantFuncMathMore	#endif // ROOT_Math_QuantFuncMathCore

	#endif // if defined (__CINT__) && !defined(__MAKECINT__)	#endif // if defined (__CINT__) && !defined(__MAKECINT__)

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

	QuantFuncMathMore.h	QuantFuncMathMore.h

	skipping to change at line 80	skipping to change at line 80
	/** @name Quantile Functions from MathMore	/** @name Quantile Functions from MathMore
	* The implementation used is that of	* The implementation used is that of
	* <A HREF="http://www.gnu.org/software/gsl/manual/html_node/Random-Numbe r-Distributions.html">GSL</A>.	* <A HREF="http://www.gnu.org/software/gsl/manual/html_node/Random-Numbe r-Distributions.html">GSL</A>.
	*/	*/

	//@{	//@{

	/**	/**

	Inverse (\f$D^{-1}(z)\f$) of the cumulative distribution	Inverse (\f$D^{-1}(z)\f$) of the cumulative distribution

	function of the lower tail of the \f$\chi^2\f$ distribution
	with \f$r\f$ degrees of freedom (#chisquared_cdf). For detailed descripti
	on see
	<A HREF="http://mathworld.wolfram.com/Chi-SquaredDistribution.html">
	Mathworld</A>. The implementation used is that of
	<A HREF="http://www.gnu.org/software/gsl/manual/gsl-ref_19.html#SEC303">G
	SL</A>.

	@ingroup QuantFunc

	*/

	double chisquared_quantile(double z, double r);

	/**

	Inverse (\f$D^{-1}(z)\f$) of the cumulative distribution
	function of the lower tail of the gamma distribution
	(#gamma_cdf). For detailed description see
	<A HREF="http://mathworld.wolfram.com/GammaDistribution.html">
	Mathworld</A>. The implementation used is that of
	<A HREF="http://www.gnu.org/software/gsl/manual/gsl-ref_19.html#SEC300">G
	SL</A>.

	@ingroup QuantFunc

	*/

	double gamma_quantile(double z, double alpha, double theta);

	/**

	Inverse (\f$D^{-1}(z)\f$) of the cumulative distribution
	function of the upper tail of Student's t-distribution	function of the upper tail of Student's t-distribution
	(#tdistribution_cdf_c). For detailed description see	(#tdistribution_cdf_c). For detailed description see
	<A HREF="http://mathworld.wolfram.com/Studentst-Distribution.html">	<A HREF="http://mathworld.wolfram.com/Studentst-Distribution.html">
	Mathworld</A>. The implementation used is that of	Mathworld</A>. The implementation used is that of
	<A HREF="http://www.gnu.org/software/gsl/manual/gsl-ref_19.html#SEC305">G SL</A>.	<A HREF="http://www.gnu.org/software/gsl/manual/gsl-ref_19.html#SEC305">G SL</A>.

	@ingroup QuantFunc	@ingroup QuantFunc

	*/	*/


	skipping to change at line 162	skipping to change at line 132
	return tdistribution_quantile_c (x, r );	return tdistribution_quantile_c (x, r );
	}	}

	inline double tdistribution_quant_inv(double x, double r) {	inline double tdistribution_quant_inv(double x, double r) {
	return tdistribution_quantile (x, r );	return tdistribution_quantile (x, r );
	}	}

	#endif	#endif

	} // namespace Math	} // namespace Math


		namespace MathMore {

		/**

		Re-implementation in MathMore of the Inverse (\f$D^{-1}(z)\f$) of the cum
		ulative distribution
		function of the lower tail of the \f$\chi^2\f$ distribution
		with \f$r\f$ degrees of freedom (#chisquared_cdf). For detailed descripti
		on see
		<A HREF="http://mathworld.wolfram.com/Chi-SquaredDistribution.html">
		Mathworld</A>. The implementation used is that of
		<A HREF="http://www.gnu.org/software/gsl/manual/gsl-ref_19.html#SEC303">G
		SL</A>.

		@ingroup QuantFunc

		*/

		double chisquared_quantile(double z, double r);

		/**

		Re-implementation in MathMore of the Inverse (\f$D^{-1}(z)\f$) of the cum
		ulative distribution
		function of the lower tail of the gamma distribution
		(#gamma_cdf). For detailed description see
		<A HREF="http://mathworld.wolfram.com/GammaDistribution.html">
		Mathworld</A>. The implementation used is that of
		<A HREF="http://www.gnu.org/software/gsl/manual/gsl-ref_19.html#SEC300">G
		SL</A>.

		@ingroup QuantFunc

		*/

		double gamma_quantile(double z, double alpha, double theta);

		} // end namespace MathMore
	} // namespace ROOT	} // namespace ROOT

	#endif // ROOT_Math_QuantFuncMathMore	#endif // ROOT_Math_QuantFuncMathMore

	#endif // if defined (__CINT__) && !defined(__MAKECINT__)	#endif // if defined (__CINT__) && !defined(__MAKECINT__)

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

	RConfig.h	RConfig.h

	/* @(#)root/base:$Id: RConfig.h 35471 2010-09-20 16:35:01Z rdm $ */	/* @(#)root/base:$Id: RConfig.h 37326 2010-12-06 11:07:19Z rdm $ */

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2002, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2002, 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_RConfig	#ifndef ROOT_RConfig

	skipping to change at line 372	skipping to change at line 372
	# endif	# endif
	# if defined(__amd64__)	# if defined(__amd64__)
	# define R__B64	# define R__B64
	# endif	# endif
	# define R__THROWNEWDELETE /* new/delete throw exceptions */	# define R__THROWNEWDELETE /* new/delete throw exceptions */
	# define HAS_STRLCPY	# define HAS_STRLCPY
	#endif	#endif

	#if defined(__APPLE__) /* MacOS X support, initially following FreeBS D */	#if defined(__APPLE__) /* MacOS X support, initially following FreeBS D */
	# include <AvailabilityMacros.h>	# include <AvailabilityMacros.h>

		# ifndef __CINT__
		# include <TargetConditionals.h>
		# endif
	# define R__MACOSX	# define R__MACOSX
	# define R__UNIX	# define R__UNIX
	# if defined(__xlC__) \|\| defined(__xlc__)	# if defined(__xlC__) \|\| defined(__xlc__)
	# define ANSICPP	# define ANSICPP
	# define R__ANSISTREAM	# define R__ANSISTREAM
	# define R__PLACEMENTINLINE /* placement new/delete is inline in <new> */	# define R__PLACEMENTINLINE /* placement new/delete is inline in <new> */
	# endif	# endif
	# if defined(__ppc64__)	# if defined(__ppc64__)
	# define R__B64 /* enable when 64 bit machine */	# define R__B64 /* enable when 64 bit machine */
	# endif	# endif
	# if defined(__i386__)	# if defined(__i386__)
	# define R__BYTESWAP	# define R__BYTESWAP
	# endif	# endif

		# if defined(__arm__)
		# define R__BYTESWAP
		# endif
	# if defined(__x86_64__)	# if defined(__x86_64__)
	# define R__BYTESWAP	# define R__BYTESWAP
	# define R__B64 /* enable when 64 bit machine */	# define R__B64 /* enable when 64 bit machine */
	# endif	# endif
	# define HAS_STRLCPY	# define HAS_STRLCPY
	#endif	#endif

	#ifdef _HIUX_SOURCE	#ifdef _HIUX_SOURCE
	# define R__HIUX	# define R__HIUX
	# define R__UNIX	# define R__UNIX

	skipping to change at line 537	skipping to change at line 543
	# define _NAME2_(name1,name2) _NAME1_(name1)name2	# define _NAME2_(name1,name2) _NAME1_(name1)name2
	# define _NAME3_(name1,name2,name3) _NAME2_(name1,name2)name3	# define _NAME3_(name1,name2,name3) _NAME2_(name1,name2)name3

	# define _QUOTE_(name) "name"	# define _QUOTE_(name) "name"

	#endif	#endif

	/* produce an identifier that is almost unique inside a file */	/* produce an identifier that is almost unique inside a file */
	#ifndef __CINT__	#ifndef __CINT__
	# define _R__JOIN_(X,Y) _NAME2_(X,Y)	# define _R__JOIN_(X,Y) _NAME2_(X,Y)

		# define _R__JOIN3_(F,X,Y) _NAME3_(F,X,Y)
		#ifdef R__DICTIONARY_FILENAME
		# define _R__UNIQUE_(X) _R__JOIN3_(R__DICTIONARY_FILENAME,X,__LINE__)
		#else
	# define _R__UNIQUE_(X) _R__JOIN_(X,__LINE__)	# define _R__UNIQUE_(X) _R__JOIN_(X,__LINE__)

		#endif
	#else	#else
	/* Currently CINT does not really mind to have duplicates and */	/* Currently CINT does not really mind to have duplicates and */
	/* does not work correctly as far as merging tokens is concerned. */	/* does not work correctly as far as merging tokens is concerned. */
	# define _R__UNIQUE_(X) X	# define _R__UNIQUE_(X) X
	#endif	#endif

	/---- misc --------------------------------------------------------------- ---/	/---- misc --------------------------------------------------------------- ---/

	#ifdef R__GNU	#ifdef R__GNU
	# define SafeDelete(p) { if (p) { delete p; p = 0; } }	# define SafeDelete(p) { if (p) { delete p; p = 0; } }

End of changes. 5 change blocks.
	1 lines changed or deleted	12 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.27/06"	#define ROOT_RELEASE "5.28/00"
	#define ROOT_RELEASE_DATE "Sep 29 2010"	#define ROOT_RELEASE_DATE "Dec 14 2010"
	#define ROOT_RELEASE_TIME "10:42:31"	#define ROOT_RELEASE_TIME "08:34:00"
	#define ROOT_SVN_REVISION 35855	#define ROOT_SVN_REVISION 37583
	#define ROOT_SVN_BRANCH "trunk"	#define ROOT_SVN_BRANCH "trunk"

	#define ROOT_VERSION_CODE 334598	#define ROOT_VERSION_CODE 334848
	#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. 2 change blocks.
	5 lines changed or deleted	5 lines changed or added

	Random.h	Random.h

	// @(#)root/mathmore:$Id: Random.h 21553 2007-12-21 10:55:46Z moneta $	// @(#)root/mathmore:$Id: Random.h 37442 2010-12-09 16:36:55Z moneta $
	// Author: L. Moneta, A. Zsenei 08/2005	// Author: L. Moneta, A. Zsenei 08/2005

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *
	* *	* *
	* This library is free software; you can redistribute it and/or *	* This library is free software; you can redistribute it and/or *
	* modify it under the terms of the GNU General Public License *	* modify it under the terms of the GNU General Public License *
	* as published by the Free Software Foundation; either version 2 *	* as published by the Free Software Foundation; either version 2 *
	* of the License, or (at your option) any later version. *	* of the License, or (at your option) any later version. *

	skipping to change at line 270	skipping to change at line 270
	}	}

	/**	/**
	Binomial distribution	Binomial distribution
	*/	*/
	unsigned int Binomial(unsigned int ntot, double prob) {	unsigned int Binomial(unsigned int ntot, double prob) {
	return fEngine.Binomial(prob,ntot);	return fEngine.Binomial(prob,ntot);
	}	}

	/**	/**

		Negative Binomial distribution
		First parameter is n, second is probability
		To be consistent with Random::Binomial
		*/
		unsigned int NegativeBinomial(double n, double prob) {
		return fEngine.NegativeBinomial(prob,n);
		}

		/**
	Multinomial distribution	Multinomial distribution
	*/	*/
	std::vector<unsigned int> Multinomial( unsigned int ntot, const std::ve ctor<double> & p ) {	std::vector<unsigned int> Multinomial( unsigned int ntot, const std::ve ctor<double> & p ) {
	return fEngine.Multinomial(ntot,p);	return fEngine.Multinomial(ntot,p);
	}	}

	private:	private:

	Engine fEngine;	Engine fEngine;


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

	RatioOfProfiledLikelihoodsTestStat.h	RatioOfProfiledLikelihoodsTestStat.h

	// @(#)root/roostats:$Id: RatioOfProfiledLikelihoodsTestStat.h 34109 2010-0 6-24 15:00:16Z moneta $	// @(#)root/roostats:$Id: RatioOfProfiledLikelihoodsTestStat.h 36602 2010-1 1-11 16:52:13Z moneta $
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, 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 ROOSTATS_RatioOfProfiledLikelihoodsTestStat	#ifndef ROOSTATS_RatioOfProfiledLikelihoodsTestStat
	#define ROOSTATS_RatioOfProfiledLikelihoodsTestStat	#define ROOSTATS_RatioOfProfiledLikelihoodsTestStat

	skipping to change at line 39	skipping to change at line 39
	#endif	#endif

	#ifndef ROOSTATS_TestStatistic	#ifndef ROOSTATS_TestStatistic
	#include "RooStats/TestStatistic.h"	#include "RooStats/TestStatistic.h"
	#endif	#endif

	namespace RooStats {	namespace RooStats {

	class RatioOfProfiledLikelihoodsTestStat: public TestStatistic {	class RatioOfProfiledLikelihoodsTestStat: public TestStatistic {


	public:	public:

		RatioOfProfiledLikelihoodsTestStat() :
		fNullPdf(NULL),
		fAltPdf(NULL),
		fAltPOI(NULL),
		fSubtractMLE(true)
		{
		// Proof constructor. Don't use.
		}

	RatioOfProfiledLikelihoodsTestStat(RooAbsPdf& nullPdf, RooAbsPdf& altPdf,	RatioOfProfiledLikelihoodsTestStat(RooAbsPdf& nullPdf, RooAbsPdf& altPdf,
	const RooArgSet* altPOI=0) :	const RooArgSet* altPOI=0) :

	fNullPdf(nullPdf), fAltPdf(altPdf), fSubtractMLE(true)	fNullPdf(&nullPdf), fAltPdf(&altPdf), fSubtractMLE(true)
	{	{
	/*	/*
	Calculates the ratio of profiled likelihoods.	Calculates the ratio of profiled likelihoods.

	By default the calculation is:	By default the calculation is:

	Lambda(mu_alt , conditional MLE for alt nuisance)	Lambda(mu_alt , conditional MLE for alt nuisance)
	log --------------------------------------------	log --------------------------------------------
	Lambda(mu_null , conditional MLE for null nuisance)	Lambda(mu_null , conditional MLE for null nuisance)


	skipping to change at line 109	skipping to change at line 119
	delete nll;	delete nll;

	return nllVal;	return nllVal;
	}	}

	//__________________________________________	//__________________________________________
	virtual Double_t Evaluate(RooAbsData& data, RooArgSet& nullParamsOfInte rest) {	virtual Double_t Evaluate(RooAbsData& data, RooArgSet& nullParamsOfInte rest) {
	RooFit::MsgLevel msglevel = RooMsgService::instance().globalKillBelow ();	RooFit::MsgLevel msglevel = RooMsgService::instance().globalKillBelow ();
	RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL);	RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL);


	/*	/*
	// if we want to set params back to what they were	// construct allVars
	RooArgSet *nullParams = fNullPdf.getParameters(data);	RooArgSet *allVars = fNullPdf->getVariables();
	RooArgSet *altParams = fAltPdf.getParameters(data);	RooArgSet *altVars = fAltPdf->getVariables();
	allVars->add(*altVars);	allVars->add(*altVars);

		delete altVars;

		RooArgSet saveNullPOI = (RooArgSet)nullParamsOfInterest.snapshot();
	RooArgSet saveAll = (RooArgSet)allVars->snapshot();	RooArgSet saveAll = (RooArgSet)allVars->snapshot();

	*/	*/

	// null	// null

	double nullNLL = ProfiledLikelihood(data, nullParamsOfInterest, fNull Pdf);	double nullNLL = ProfiledLikelihood(data, nullParamsOfInterest, *fNul lPdf);

	// alt	// alt

	double altNLL = ProfiledLikelihood(data, *fAltPOI, fAltPdf);	double altNLL = ProfiledLikelihood(data, fAltPOI, fAltPdf);


	/*	/*
	// set variables back to where they were	// set variables back to where they were

		nullParamsOfInterest = *saveNullPOI;
	allVars = saveAll;	allVars = saveAll;
	delete saveAll;	delete saveAll;
	delete allVars;	delete allVars;

	*/	*/

	RooMsgService::instance().setGlobalKillBelow(msglevel);	RooMsgService::instance().setGlobalKillBelow(msglevel);
	return nullNLL -altNLL;	return nullNLL -altNLL;
	}	}

	virtual const TString GetVarName() const { return "log(L(#mu_{1},#hat{# nu}_{1}) / L(#mu_{0},#hat{#nu}_{0}))"; }	virtual const TString GetVarName() const { return "log(L(#mu_{1},#hat{# nu}_{1}) / L(#mu_{0},#hat{#nu}_{0}))"; }

	// const bool PValueIsRightTail(void) { return false; } // overwrite s default	// const bool PValueIsRightTail(void) { return false; } // overwrite s default

	void SetSubtractMLE(bool subtract){fSubtractMLE = subtract;}	void SetSubtractMLE(bool subtract){fSubtractMLE = subtract;}

	private:	private:

	RooAbsPdf& fNullPdf;	RooAbsPdf* fNullPdf;
	RooAbsPdf& fAltPdf;	RooAbsPdf* fAltPdf;
	RooArgSet* fAltPOI;	RooArgSet* fAltPOI;
	Bool_t fSubtractMLE;	Bool_t fSubtractMLE;

	protected:	protected:

	ClassDef(RatioOfProfiledLikelihoodsTestStat,1)	ClassDef(RatioOfProfiledLikelihoodsTestStat,2)
	};	};

	}	}

	#endif	#endif

End of changes. 13 change blocks.
	15 lines changed or deleted	29 lines changed or added

	Reader.h	Reader.h

	// @(#)root/tmva $Id: Reader.h 34022 2010-06-21 15:52:50Z stelzer $	// @(#)root/tmva $Id: Reader.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss, Ka i Voss	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss, Ka i Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : Reader *	* Class : Reader *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Reader class to be used in the user application to interpret the tr ained *	* Reader class to be used in the user application to interpret the tr ained *

	skipping to change at line 104	skipping to change at line 104

	// returns the MVA response for given event	// returns the MVA response for given event
	Double_t EvaluateMVA( const std::vector<Float_t> &, const TString& me thodTag, Double_t aux = 0 );	Double_t EvaluateMVA( const std::vector<Float_t> &, const TString& me thodTag, Double_t aux = 0 );
	Double_t EvaluateMVA( const std::vector<Double_t>&, const TString& me thodTag, Double_t aux = 0 );	Double_t EvaluateMVA( const std::vector<Double_t>&, const TString& me thodTag, Double_t aux = 0 );
	Double_t EvaluateMVA( MethodBase* method, Double_t aux = 0 );	Double_t EvaluateMVA( MethodBase* method, Double_t aux = 0 );
	Double_t EvaluateMVA( const TString& methodTag, Double_t aux = 0 );	Double_t EvaluateMVA( const TString& methodTag, Double_t aux = 0 );

	// returns error on MVA response for given event	// returns error on MVA response for given event
	// NOTE: must be called AFTER "EvaluateMVA(...)" call !	// NOTE: must be called AFTER "EvaluateMVA(...)" call !
	Double_t GetMVAError() const { return fMvaEventError; }	Double_t GetMVAError() const { return fMvaEventError; }

	Double_t GetMVAError2() const { return fMvaEventError2; } //zj	Double_t GetMVAErrorLower() const { return fMvaEventError; }
	h	Double_t GetMVAErrorUpper() const { return fMvaEventErrorUpper; }

	// regression response	// regression response
	const std::vector< Float_t >& EvaluateRegression( const TString& meth odTag, Double_t aux = 0 );	const std::vector< Float_t >& EvaluateRegression( const TString& meth odTag, Double_t aux = 0 );
	const std::vector< Float_t >& EvaluateRegression( MethodBase* method, Double_t aux = 0 );	const std::vector< Float_t >& EvaluateRegression( MethodBase* method, Double_t aux = 0 );
	Float_t EvaluateRegression( UInt_t tgtNumber, const TString& methodT ag, Double_t aux = 0 );	Float_t EvaluateRegression( UInt_t tgtNumber, const TString& methodT ag, Double_t aux = 0 );

	// multiclass response	// multiclass response
	const std::vector< Float_t >& EvaluateMulticlass( const TString& meth odTag, Double_t aux = 0 );	const std::vector< Float_t >& EvaluateMulticlass( const TString& meth odTag, Double_t aux = 0 );
	const std::vector< Float_t >& EvaluateMulticlass( MethodBase* method, Double_t aux = 0 );	const std::vector< Float_t >& EvaluateMulticlass( MethodBase* method, Double_t aux = 0 );
	Float_t EvaluateMulticlass( UInt_t clsNumber, const TString& methodT ag, Double_t aux = 0 );	Float_t EvaluateMulticlass( UInt_t clsNumber, const TString& methodT ag, Double_t aux = 0 );

	skipping to change at line 156	skipping to change at line 157

	// Init Reader class	// Init Reader class
	void Init( void );	void Init( void );

	// Decode Constructor string (or TString) and fill variable name std: :vector	// Decode Constructor string (or TString) and fill variable name std: :vector
	void DecodeVarNames( const std::string& varNames );	void DecodeVarNames( const std::string& varNames );
	void DecodeVarNames( const TString& varNames );	void DecodeVarNames( const TString& varNames );

	void DeclareOptions();	void DeclareOptions();


	Bool_t fVerbose; // verbosity	Bool_t fVerbose; // verbosity
	Bool_t fSilent; // silent mode	Bool_t fSilent; // silent mode
	Bool_t fColor; // color mode	Bool_t fColor; // color mode
		Bool_t fCalculateError; // error calculation mode


	Double_t fMvaEventError; // per-event error returned by MVA (unless:	Double_t fMvaEventError; // per-event error returned by MVA
	-1)	Double_t fMvaEventErrorUpper; // per-event error returned by MVA
	Double_t fMvaEventError2; // per-event error returned by MVA (unless
	: -1) //zjh

	std::map<TString, IMethod*> fMethodMap; // map of methods	std::map<TString, IMethod*> fMethodMap; // map of methods


	std::vector<Float_t> fTmpEvalVec; // temporary evaluation vect or (if user input is v<double>)	std::vector<Float_t> fTmpEvalVec; // temporary evaluation vector (if user input is v<double>)

	mutable MsgLogger* fLogger; // message logger	mutable MsgLogger* fLogger; // message logger
	MsgLogger& Log() const { return *fLogger; }	MsgLogger& Log() const { return *fLogger; }

	ClassDef(Reader,0) // Interpret the trained MVAs in an analysis conte xt	ClassDef(Reader,0) // Interpret the trained MVAs in an analysis conte xt
	};	};

	}	}

	#endif	#endif

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

	ResultsMulticlass.h	ResultsMulticlass.h

	// @(#)root/tmva $Id: ResultsMulticlass.h 35727 2010-09-24 21:41:20Z stelze r $	// @(#)root/tmva $Id: ResultsMulticlass.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : ResultsMulticlass *	* Class : ResultsMulticlass *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Base-class for result-vectors *	* Base-class for result-vectors *

	skipping to change at line 55	skipping to change at line 55
	#ifndef ROOT_TH2F	#ifndef ROOT_TH2F
	#include "TH2F.h"	#include "TH2F.h"
	#endif	#endif

	#ifndef ROOT_TMVA_Results	#ifndef ROOT_TMVA_Results
	#include "TMVA/Results.h"	#include "TMVA/Results.h"
	#endif	#endif
	#ifndef ROOT_TMVA_Event	#ifndef ROOT_TMVA_Event
	#include "TMVA/Event.h"	#include "TMVA/Event.h"
	#endif	#endif

		#ifndef ROOT_IFitterTarget
		#include "IFitterTarget.h"
		#endif

	namespace TMVA {	namespace TMVA {

	class MsgLogger;	class MsgLogger;


	class ResultsMulticlass : public Results {	class ResultsMulticlass : public Results, public IFitterTarget {

	public:	public:

	ResultsMulticlass( const DataSetInfo* dsi );	ResultsMulticlass( const DataSetInfo* dsi );
	~ResultsMulticlass();	~ResultsMulticlass();

	// setters	// setters
	void SetValue( std::vector<Float_t>& value, Int_t ievt );	void SetValue( std::vector<Float_t>& value, Int_t ievt );
	void Resize( Int_t entries ) { fMultiClassValues.resize( entries ); }	void Resize( Int_t entries ) { fMultiClassValues.resize( entries ); }
	void Clear() { fMultiClassValues.clear(); }	void Clear() { fMultiClassValues.clear(); }

	// getters	// getters
	Long64_t GetSize() const { return fMultiClassValues.size(); }	Long64_t GetSize() const { return fMultiClassValues.size(); }
	virtual const std::vector< Float_t >& operator[] ( Int_t ievt ) cons t { return fMultiClassValues.at(ievt); }	virtual const std::vector< Float_t >& operator[] ( Int_t ievt ) cons t { return fMultiClassValues.at(ievt); }
	std::vector<std::vector< Float_t> >* GetValueVector() { return &fMul tiClassValues; }	std::vector<std::vector< Float_t> >* GetValueVector() { return &fMul tiClassValues; }

	Types::EAnalysisType GetAnalysisType() { return Types::kMulticlass; }	Types::EAnalysisType GetAnalysisType() { return Types::kMulticlass; }

		Float_t GetAchievableEff(UInt_t cls){return fAchievableEff.at(cls);}
		Float_t GetAchievablePur(UInt_t cls){return fAchievablePur.at(cls);}
		std::vector<Float_t>& GetAchievableEff(){return fAchievableEff;}
		std::vector<Float_t>& GetAchievablePur(){return fAchievablePur;}
	// histogramming	// histogramming

	void MakeHistograms();	void CreateMulticlassHistos( TString prefix, Int_t nbins, Int_t n
		bins_high);

		Double_t EstimatorFunction( std::vector<Double_t> & );
		std::vector<Double_t> GetBestMultiClassCuts(UInt_t targetClass);

	private:	private:

	mutable std::vector<std::vector< Float_t> > fMultiClassValues; //! mva values (Results)	mutable std::vector<std::vector< Float_t> > fMultiClassValues; //! mva values (Results)
	mutable MsgLogger* fLogger; //! message logger	mutable MsgLogger* fLogger; //! message logger
	MsgLogger& Log() const { return *fLogger; }	MsgLogger& Log() const { return *fLogger; }

		UInt_t fClassToOptimize;
		std::vector<Float_t> fAchievableEff;
		std::vector<Float_t> fAchievablePur;
		std::vector<std::vector<Double_t> > fBestCuts;
	};	};


	}	}

	#endif	#endif

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

	Roo1DTable.h	Roo1DTable.h

	skipping to change at line 31	skipping to change at line 31
	#include "TObjArray.h"	#include "TObjArray.h"
	#include "RooTable.h"	#include "RooTable.h"
	#include <vector>	#include <vector>

	class Roo1DTable : public RooTable {	class Roo1DTable : public RooTable {
	public:	public:

	// Constructors, cloning and assignment	// Constructors, cloning and assignment
	Roo1DTable() {	Roo1DTable() {
	// Default constructor	// Default constructor

		// coverity[UNINIT_CTOR]
	} ;	} ;
	virtual ~Roo1DTable();	virtual ~Roo1DTable();
	Roo1DTable(const char name, const char title, const RooAbsCategory &cat );	Roo1DTable(const char name, const char title, const RooAbsCategory &cat );
	Roo1DTable(const Roo1DTable& other) ;	Roo1DTable(const Roo1DTable& other) ;

	virtual void fill(RooAbsCategory& cat, Double_t weight=1.0) ;	virtual void fill(RooAbsCategory& cat, Double_t weight=1.0) ;
	Double_t get(const char* label, Bool_t silent=kFALSE) const ;	Double_t get(const char* label, Bool_t silent=kFALSE) const ;
	Double_t getFrac(const char* label, Bool_t silent=kFALSE) const ;	Double_t getFrac(const char* label, Bool_t silent=kFALSE) const ;
	Double_t getOverflow() const ;	Double_t getOverflow() const ;


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

	RooAbsArg.h	RooAbsArg.h

	skipping to change at line 41	skipping to change at line 41
	class RooAbsCollection ;	class RooAbsCollection ;
	class RooTreeData ;	class RooTreeData ;
	class RooTreeDataStore ;	class RooTreeDataStore ;
	class RooAbsData ;	class RooAbsData ;
	class RooAbsDataStore ;	class RooAbsDataStore ;
	class RooAbsProxy ;	class RooAbsProxy ;
	class RooArgProxy ;	class RooArgProxy ;
	class RooSetProxy ;	class RooSetProxy ;
	class RooListProxy ;	class RooListProxy ;
	class RooExpensiveObjectCache ;	class RooExpensiveObjectCache ;

		class RooWorkspace ;
	/* class TGraphStruct ; */	/* class TGraphStruct ; */

	class RooAbsArg : public TNamed, public RooPrintable {	class RooAbsArg : public TNamed, public RooPrintable {
	public:	public:

	// Constructors, cloning and assignment	// Constructors, cloning and assignment
	RooAbsArg() ;	RooAbsArg() ;
	virtual ~RooAbsArg();	virtual ~RooAbsArg();
	RooAbsArg(const char name, const char title);	RooAbsArg(const char name, const char title);
	RooAbsArg(const RooAbsArg& other, const char* name=0) ;	RooAbsArg(const RooAbsArg& other, const char* name=0) ;
	virtual TObject* clone(const char* newname) const = 0 ;	virtual TObject* clone(const char* newname) const = 0 ;
	virtual TObject* Clone(const char* newname=0) const {	virtual TObject* Clone(const char* newname=0) const {
	return clone(newname?newname:GetName()) ;	return clone(newname?newname:GetName()) ;
	}	}
	virtual RooAbsArg* cloneTree(const char* newname=0) const ;	virtual RooAbsArg* cloneTree(const char* newname=0) const ;

	// Accessors to client-server relation information	// Accessors to client-server relation information
	virtual Bool_t isDerived() const {	virtual Bool_t isDerived() const {
	// Does value or shape of this arg depend on any other arg?	// Does value or shape of this arg depend on any other arg?

	return _serverList.GetSize()?kTRUE:kFALSE;	return (_serverList.GetSize()>0 \|\| _proxyList.GetSize()>0)?kTRUE:kFALSE ;
	}	}
	Bool_t isCloneOf(const RooAbsArg& other) const ;	Bool_t isCloneOf(const RooAbsArg& other) const ;
	Bool_t dependsOnValue(const RooAbsCollection& serverList, const RooAbsArg * ignoreArg=0) const {	Bool_t dependsOnValue(const RooAbsCollection& serverList, const RooAbsArg * ignoreArg=0) const {
	// Does this arg depend on the value of any of of the values in serverL ist?	// Does this arg depend on the value of any of of the values in serverL ist?
	return dependsOn(serverList,ignoreArg,kTRUE) ;	return dependsOn(serverList,ignoreArg,kTRUE) ;
	}	}
	Bool_t dependsOnValue(const RooAbsArg& server, const RooAbsArg* ignoreArg =0) const {	Bool_t dependsOnValue(const RooAbsArg& server, const RooAbsArg* ignoreArg =0) const {
	// Does this arg depend on the value of server?	// Does this arg depend on the value of server?
	return dependsOn(server,ignoreArg,kTRUE) ;	return dependsOn(server,ignoreArg,kTRUE) ;
	}	}

	skipping to change at line 392	skipping to change at line 393
	void addServer(RooAbsArg& server, Bool_t valueProp=kTRUE, Bool_t shapePro p=kFALSE) ;	void addServer(RooAbsArg& server, Bool_t valueProp=kTRUE, Bool_t shapePro p=kFALSE) ;
	void addServerList(RooAbsCollection& serverList, Bool_t valueProp=kTRUE, Bool_t shapeProp=kFALSE) ;	void addServerList(RooAbsCollection& serverList, Bool_t valueProp=kTRUE, Bool_t shapeProp=kFALSE) ;
	void replaceServer(RooAbsArg& oldServer, RooAbsArg& newServer, Bool_t val ueProp, Bool_t shapeProp) ;	void replaceServer(RooAbsArg& oldServer, RooAbsArg& newServer, Bool_t val ueProp, Bool_t shapeProp) ;
	void changeServer(RooAbsArg& server, Bool_t valueProp, Bool_t shapeProp) ;	void changeServer(RooAbsArg& server, Bool_t valueProp, Bool_t shapeProp) ;
	void removeServer(RooAbsArg& server, Bool_t force=kFALSE) ;	void removeServer(RooAbsArg& server, Bool_t force=kFALSE) ;
	RooAbsArg *findNewServer(const RooAbsCollection &newSet, Bool_t nameChang e) const;	RooAbsArg *findNewServer(const RooAbsCollection &newSet, Bool_t nameChang e) const;

	RooExpensiveObjectCache& expensiveObjectCache() const ;	RooExpensiveObjectCache& expensiveObjectCache() const ;
	void setExpensiveObjectCache(RooExpensiveObjectCache& cache) { _eocache = &cache ; }	void setExpensiveObjectCache(RooExpensiveObjectCache& cache) { _eocache = &cache ; }


		virtual Bool_t importWorkspaceHook(RooWorkspace&) { return kFALSE ; } ;

	protected:	protected:

	// Proxy management	// Proxy management
	friend class RooAddModel ;	friend class RooAddModel ;
	friend class RooArgProxy ;	friend class RooArgProxy ;
	friend class RooSetProxy ;	friend class RooSetProxy ;
	friend class RooListProxy ;	friend class RooListProxy ;
	friend class RooObjectFactory ;	friend class RooObjectFactory ;
	void registerProxy(RooArgProxy& proxy) ;	void registerProxy(RooArgProxy& proxy) ;
	void registerProxy(RooSetProxy& proxy) ;	void registerProxy(RooSetProxy& proxy) ;

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

	RooAbsData.h	RooAbsData.h

	skipping to change at line 48	skipping to change at line 48
	public:	public:

	// Constructors, factory methods etc.	// Constructors, factory methods etc.
	RooAbsData() ;	RooAbsData() ;
	RooAbsData(const char name, const char title, const RooArgSet& vars, Ro oAbsDataStore* store=0) ;	RooAbsData(const char name, const char title, const RooArgSet& vars, Ro oAbsDataStore* store=0) ;
	RooAbsData(const RooAbsData& other, const char* newname = 0) ;	RooAbsData(const RooAbsData& other, const char* newname = 0) ;
	virtual ~RooAbsData() ;	virtual ~RooAbsData() ;
	virtual RooAbsData* emptyClone(const char* newName=0, const char* newTitl e=0, const RooArgSet* vars=0) const = 0 ;	virtual RooAbsData* emptyClone(const char* newName=0, const char* newTitl e=0, const RooArgSet* vars=0) const = 0 ;

	// Reduction methods	// Reduction methods

	RooAbsData* reduce(RooCmdArg arg1,RooCmdArg arg2=RooCmdArg(),RooCmdArg ar	RooAbsData* reduce(const RooCmdArg& arg1,const RooCmdArg& arg2=RooCmdArg(
	g3=RooCmdArg(),RooCmdArg arg4=RooCmdArg(),	),const RooCmdArg& arg3=RooCmdArg(),const RooCmdArg& arg4=RooCmdArg(),
	RooCmdArg arg5=RooCmdArg(),RooCmdArg arg6=RooCmdArg(),	const RooCmdArg& arg5=RooCmdArg(),const RooCmdArg& arg
	RooCmdArg arg7=RooCmdArg(),RooCmdArg arg8=RooCmdArg()) ;	6=RooCmdArg(),const RooCmdArg& arg7=RooCmdArg(),const RooCmdArg& arg8=RooCm
		dArg()) ;
	RooAbsData* reduce(const char* cut) ;	RooAbsData* reduce(const char* cut) ;
	RooAbsData* reduce(const RooFormulaVar& cutVar) ;	RooAbsData* reduce(const RooFormulaVar& cutVar) ;
	RooAbsData* reduce(const RooArgSet& varSubset, const char* cut=0) ;	RooAbsData* reduce(const RooArgSet& varSubset, const char* cut=0) ;
	RooAbsData* reduce(const RooArgSet& varSubset, const RooFormulaVar& cutVa r) ;	RooAbsData* reduce(const RooArgSet& varSubset, const RooFormulaVar& cutVa r) ;

	RooAbsDataStore* store() { return _dstore ; }	RooAbsDataStore* store() { return _dstore ; }
	const RooAbsDataStore* store() const { return _dstore ; }	const RooAbsDataStore* store() const { return _dstore ; }
	const TTree* tree() const ;	const TTree* tree() const ;

	virtual void Draw(Option_t* option = "") ;	virtual void Draw(Option_t* option = "") ;

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

	RooAbsNumGenerator.h	RooAbsNumGenerator.h
	/************************************************************************ *	/************************************************************************ *
	* Project: RooFit *	* Project: RooFit *
	* Package: RooFitCore *	* Package: RooFitCore *

	* File: $Id: RooAbsNumGenerator.h 34064 2010-06-22 15:05:19Z wouter $	* File: $Id: RooAbsNumGenerator.h 36209 2010-10-08 21:37:36Z wouter $
	* Authors: *	* Authors: *
	* WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *	* WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *
	* DK, David Kirkby, UC Irvine, dkirkby@uci.edu *	* DK, David Kirkby, UC Irvine, dkirkby@uci.edu *
	* *	* *
	* 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) *

	skipping to change at line 32	skipping to change at line 32
	#include "RooArgList.h"	#include "RooArgList.h"

	class RooAbsReal;	class RooAbsReal;
	class RooRealVar;	class RooRealVar;
	class RooDataSet;	class RooDataSet;
	class RooRealBinding;	class RooRealBinding;
	class RooNumGenConfig ;	class RooNumGenConfig ;

	class RooAbsNumGenerator : public TNamed, public RooPrintable {	class RooAbsNumGenerator : public TNamed, public RooPrintable {
	public:	public:

	RooAbsNumGenerator() : _cloneSet(0), _funcClone(0), _funcMaxVal(0), _func ValStore(0), _funcValPtr(0), _cache(0) {} ;	RooAbsNumGenerator() : _cloneSet(0), _funcClone(0), _funcMaxVal(0), _verb ose(kFALSE), _isValid(kFALSE), _funcValStore(0), _funcValPtr(0), _cache(0) {} ;
	RooAbsNumGenerator(const RooAbsReal &func, const RooArgSet &genVars, Bool _t verbose=kFALSE, const RooAbsReal* maxFuncVal=0);	RooAbsNumGenerator(const RooAbsReal &func, const RooArgSet &genVars, Bool _t verbose=kFALSE, const RooAbsReal* maxFuncVal=0);
	virtual RooAbsNumGenerator* clone(const RooAbsReal&, const RooArgSet& gen Vars, const RooArgSet& condVars,	virtual RooAbsNumGenerator* clone(const RooAbsReal&, const RooArgSet& gen Vars, const RooArgSet& condVars,
	const RooNumGenConfig& config, Bool_t ve rbose=kFALSE, const RooAbsReal* maxFuncVal=0) const = 0 ;	const RooNumGenConfig& config, Bool_t ve rbose=kFALSE, const RooAbsReal* maxFuncVal=0) const = 0 ;

	Bool_t isValid() const {	Bool_t isValid() const {
	// If true, generator is in a valid state	// If true, generator is in a valid state
	return _isValid;	return _isValid;
	}	}
	virtual ~RooAbsNumGenerator();	virtual ~RooAbsNumGenerator();


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

	RooAbsOptTestStatistic.h	RooAbsOptTestStatistic.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_ABS_OPT_TEST_STATISTIC	#ifndef ROO_ABS_OPT_TEST_STATISTIC
	#define ROO_ABS_OPT_TEST_STATISTIC	#define ROO_ABS_OPT_TEST_STATISTIC

	#include "Riosfwd.h"	#include "Riosfwd.h"
	#include "RooAbsTestStatistic.h"	#include "RooAbsTestStatistic.h"
	#include "RooSetProxy.h"	#include "RooSetProxy.h"
	#include "RooCategoryProxy.h"	#include "RooCategoryProxy.h"

		#include "TString.h"

	class RooArgSet ;	class RooArgSet ;
	class RooAbsData ;	class RooAbsData ;
	class RooAbsReal ;	class RooAbsReal ;

	class RooAbsOptTestStatistic : public RooAbsTestStatistic {	class RooAbsOptTestStatistic : public RooAbsTestStatistic {
	public:	public:

	// Constructors, assignment etc	// Constructors, assignment etc
	RooAbsOptTestStatistic() ;	RooAbsOptTestStatistic() ;

	skipping to change at line 44	skipping to change at line 45
	const RooArgSet& projDeps, const char* rangeName=0, const char* addCoefRangeName=0,	const RooArgSet& projDeps, const char* rangeName=0, const char* addCoefRangeName=0,
	Int_t nCPU=1, Bool_t interleave=kFALSE, Bool_t verb ose=kTRUE, Bool_t splitCutRange=kFALSE,	Int_t nCPU=1, Bool_t interleave=kFALSE, Bool_t verb ose=kTRUE, Bool_t splitCutRange=kFALSE,
	Bool_t cloneInputData=kTRUE) ;	Bool_t cloneInputData=kTRUE) ;
	RooAbsOptTestStatistic(const RooAbsOptTestStatistic& other, const char* n ame=0);	RooAbsOptTestStatistic(const RooAbsOptTestStatistic& other, const char* n ame=0);
	virtual ~RooAbsOptTestStatistic();	virtual ~RooAbsOptTestStatistic();

	virtual Double_t combinedValue(RooAbsReal** gofArray, Int_t nVal) const ;	virtual Double_t combinedValue(RooAbsReal** gofArray, Int_t nVal) const ;

	RooAbsReal& function() { return *_funcClone ; }	RooAbsReal& function() { return *_funcClone ; }
	const RooAbsReal& function() const { return *_funcClone ; }	const RooAbsReal& function() const { return *_funcClone ; }

	RooAbsData& data() { return *_dataClone ; }
	const RooAbsData& data() const { return *_dataClone ; }


		RooAbsData& data() ;
		const RooAbsData& data() const ;
	Bool_t setData(RooAbsData& data, Bool_t cloneData=kTRUE) ;	Bool_t setData(RooAbsData& data, Bool_t cloneData=kTRUE) ;

	virtual const char* cacheUniqueSuffix() const { return Form("_%lx", (ULon g_t)_dataClone) ; }	virtual const char* cacheUniqueSuffix() const { return Form("_%lx", (ULon g_t)_dataClone) ; }

	// Override this to be always true to force calculation of likelihood wit hout parameters	// Override this to be always true to force calculation of likelihood wit hout parameters
	virtual Bool_t isDerived() const { return kTRUE ; }	virtual Bool_t isDerived() const { return kTRUE ; }


		void seal(const char* notice="") { _sealed = kTRUE ; _sealNotice = notice
		; }
		Bool_t isSealed() const { return _sealed ; }
		const char* sealNotice() const { return _sealNotice.Data() ; }

	protected:	protected:

	friend class RooAbsReal ;	friend class RooAbsReal ;

	virtual Bool_t allowFunctionCache() { return kTRUE ; }	virtual Bool_t allowFunctionCache() { return kTRUE ; }
	void constOptimizeTestStatistic(ConstOpCode opcode) ;	void constOptimizeTestStatistic(ConstOpCode opcode) ;

	virtual Bool_t redirectServersHook(const RooAbsCollection& newServerList, Bool_t mustReplaceAll, Bool_t nameChange, Bool_t isRecursive) ;	virtual Bool_t redirectServersHook(const RooAbsCollection& newServerList, Bool_t mustReplaceAll, Bool_t nameChange, Bool_t isRecursive) ;
	virtual void printCompactTreeHook(ostream& os, const char* indent="") ;	virtual void printCompactTreeHook(ostream& os, const char* indent="") ;
	virtual RooArgSet requiredExtraObservables() const { return RooArgSet() ; }	virtual RooArgSet requiredExtraObservables() const { return RooArgSet() ; }
	void optimizeCaching() ;	void optimizeCaching() ;
	void optimizeConstantTerms(Bool_t) ;	void optimizeConstantTerms(Bool_t) ;

	RooArgSet* _normSet ; // Pointer to set with observables used for normal ization	RooArgSet* _normSet ; // Pointer to set with observables used for normal ization
	RooArgSet* _funcCloneSet ; // Set owning all components of internal clon e of input function	RooArgSet* _funcCloneSet ; // Set owning all components of internal clon e of input function
	RooAbsData* _dataClone ; // Pointer to internal clone if input data	RooAbsData* _dataClone ; // Pointer to internal clone if input data
	RooAbsReal* _funcClone ; // Pointer to internal clone of input function	RooAbsReal* _funcClone ; // Pointer to internal clone of input function
	RooArgSet* _projDeps ; // Set of projected observable	RooArgSet* _projDeps ; // Set of projected observable
	Bool_t _ownData ; // Do we own the dataset	Bool_t _ownData ; // Do we own the dataset

		Bool_t _sealed ; // Is test statistic sealed -- i.e. no access to da
	ClassDef(RooAbsOptTestStatistic,2) // Abstract base class for optimized t	ta
	est statistics	TString _sealNotice ; // User-defined notice shown when reading a sea
		led likelihood
		ClassDef(RooAbsOptTestStatistic,3) // Abstract base class for optimized t
		est statistics
	};	};

	#endif	#endif

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

	RooAbsPdf.h	RooAbsPdf.h

	skipping to change at line 20	skipping to change at line 20
	* 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_ABS_PDF	#ifndef ROO_ABS_PDF
	#define ROO_ABS_PDF	#define ROO_ABS_PDF

	#include "RooAbsReal.h"	#include "RooAbsReal.h"

	#include "RooRealIntegral.h"	//#include "RooRealIntegral.h"
	#include "RooNameSet.h"	#include "RooNameSet.h"
	#include "RooObjCacheManager.h"	#include "RooObjCacheManager.h"
	#include "RooCmdArg.h"	#include "RooCmdArg.h"

	class RooDataSet;	class RooDataSet;
	class RooDataHist ;	class RooDataHist ;
	class RooArgSet ;	class RooArgSet ;
	class RooRealProxy ;	class RooRealProxy ;
	class RooAbsGenContext ;	class RooAbsGenContext ;
	class RooFitResult ;	class RooFitResult ;
	class RooExtendPdf ;	class RooExtendPdf ;
	class RooCategory ;	class RooCategory ;
	class TPaveText;	class TPaveText;
	class TH1F;	class TH1F;
	class TH2F;	class TH2F;
	class TList ;	class TList ;
	class RooLinkedList ;	class RooLinkedList ;
	class RooNumGenConfig ;	class RooNumGenConfig ;

		class RooRealIntegral ;

	class RooAbsPdf : public RooAbsReal {	class RooAbsPdf : public RooAbsReal {
	public:	public:

	// Constructors, assignment etc	// Constructors, assignment etc
	RooAbsPdf() ;	RooAbsPdf() ;
	RooAbsPdf(const char name, const char title=0) ;	RooAbsPdf(const char name, const char title=0) ;
	RooAbsPdf(const char name, const char title, Double_t minVal, Double_t maxVal) ;	RooAbsPdf(const char name, const char title, Double_t minVal, Double_t maxVal) ;
	// RooAbsPdf(const RooAbsPdf& other, const char* name=0);	// RooAbsPdf(const RooAbsPdf& other, const char* name=0);
	virtual ~RooAbsPdf();	virtual ~RooAbsPdf();

	skipping to change at line 131	skipping to change at line 132

	// Configuration of MC generators used for this pdf	// Configuration of MC generators used for this pdf
	const RooNumGenConfig* getGeneratorConfig() const ;	const RooNumGenConfig* getGeneratorConfig() const ;
	static RooNumGenConfig* defaultGeneratorConfig() ;	static RooNumGenConfig* defaultGeneratorConfig() ;
	RooNumGenConfig* specialGeneratorConfig() const ;	RooNumGenConfig* specialGeneratorConfig() const ;
	RooNumGenConfig* specialGeneratorConfig(Bool_t createOnTheFly) ;	RooNumGenConfig* specialGeneratorConfig(Bool_t createOnTheFly) ;
	void setGeneratorConfig() ;	void setGeneratorConfig() ;
	void setGeneratorConfig(const RooNumGenConfig& config) ;	void setGeneratorConfig(const RooNumGenConfig& config) ;

	// -log(L) fits to binned and unbinned data	// -log(L) fits to binned and unbinned data

	virtual RooFitResult* fitTo(RooAbsData& data, RooCmdArg arg1=RooCmdArg::n	virtual RooFitResult* fitTo(RooAbsData& data, const RooCmdArg& arg1=RooCm
	one(), RooCmdArg arg2=RooCmdArg::none(),	dArg::none(), const RooCmdArg& arg2=RooCmdArg::none(),
	RooCmdArg arg3=RooCmdArg::none(), RooCmdArg	const RooCmdArg& arg3=RooCmdArg::none(), con
	arg4=RooCmdArg::none(), RooCmdArg arg5=RooCmdArg::none(),	st RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5=RooCmdArg::none
	RooCmdArg arg6=RooCmdArg::none(), RooCmdArg	(),
	arg7=RooCmdArg::none(), RooCmdArg arg8=RooCmdArg::none()) ;	const RooCmdArg& arg6=RooCmdArg::none(), con
		st RooCmdArg& arg7=RooCmdArg::none(), const RooCmdArg& arg8=RooCmdArg::none
		()) ;
	virtual RooFitResult* fitTo(RooAbsData& data, const RooLinkedList& cmdLis t) ;	virtual RooFitResult* fitTo(RooAbsData& data, const RooLinkedList& cmdLis t) ;

	virtual RooAbsReal* createNLL(RooAbsData& data, const RooLinkedList& cmdL ist) ;	virtual RooAbsReal* createNLL(RooAbsData& data, const RooLinkedList& cmdL ist) ;

	virtual RooAbsReal* createNLL(RooAbsData& data, RooCmdArg arg1=RooCmdArg:	virtual RooAbsReal* createNLL(RooAbsData& data, const RooCmdArg& arg1=Roo
	:none(), RooCmdArg arg2=RooCmdArg::none(),	CmdArg::none(), const RooCmdArg& arg2=RooCmdArg::none(),
	RooCmdArg arg3=RooCmdArg::none(), RooCmdArg	const RooCmdArg& arg3=RooCmdArg::none(), co
	arg4=RooCmdArg::none(), RooCmdArg arg5=RooCmdArg::none(),	nst RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5=RooCmdArg::non
	RooCmdArg arg6=RooCmdArg::none(), RooCmdArg	e(),
	arg7=RooCmdArg::none(), RooCmdArg arg8=RooCmdArg::none()) ;	const RooCmdArg& arg6=RooCmdArg::none(), co
		nst RooCmdArg& arg7=RooCmdArg::none(), const RooCmdArg& arg8=RooCmdArg::non
		e()) ;

	// Chi^2 fits to histograms	// Chi^2 fits to histograms
	using RooAbsReal::chi2FitTo ;	using RooAbsReal::chi2FitTo ;
	using RooAbsReal::createChi2 ;	using RooAbsReal::createChi2 ;
	virtual RooFitResult* chi2FitTo(RooDataHist& data, const RooLinkedList& c mdList) ;	virtual RooFitResult* chi2FitTo(RooDataHist& data, const RooLinkedList& c mdList) ;

	virtual RooAbsReal* createChi2(RooDataHist& data, RooCmdArg arg1=RooCmdAr	virtual RooAbsReal* createChi2(RooDataHist& data, const RooCmdArg& arg1=R
	g::none(), RooCmdArg arg2=RooCmdArg::none(),	ooCmdArg::none(), const RooCmdArg& arg2=RooCmdArg::none(),
	RooCmdArg arg3=RooCmdArg::none(), RooCmdAr	const RooCmdArg& arg3=RooCmdArg::none(), c
	g arg4=RooCmdArg::none(), RooCmdArg arg5=RooCmdArg::none(),	onst RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5=RooCmdArg::no
	RooCmdArg arg6=RooCmdArg::none(), RooCmdAr	ne(),
	g arg7=RooCmdArg::none(), RooCmdArg arg8=RooCmdArg::none()) ;	const RooCmdArg& arg6=RooCmdArg::none(), c
		onst RooCmdArg& arg7=RooCmdArg::none(), const RooCmdArg& arg8=RooCmdArg::no
		ne()) ;

	// Chi^2 fits to X-Y datasets	// Chi^2 fits to X-Y datasets
	virtual RooAbsReal* createChi2(RooDataSet& data, const RooLinkedList& cmd List) ;	virtual RooAbsReal* createChi2(RooDataSet& data, const RooLinkedList& cmd List) ;

	// Constraint management	// Constraint management
	virtual RooArgSet* getConstraints(const RooArgSet& /observables/, RooAr gSet& /constrainedParams/, Bool_t /stripDisconnected/) const {	virtual RooArgSet* getConstraints(const RooArgSet& /observables/, RooAr gSet& /constrainedParams/, Bool_t /stripDisconnected/) const {
	// Interface to retrieve constraint terms on this pdf. Default implemen tation returns null	// Interface to retrieve constraint terms on this pdf. Default implemen tation returns null
	return 0 ;	return 0 ;
	}	}
	virtual RooArgSet* getAllConstraints(const RooArgSet& observables, RooArg Set& constrainedParams, Bool_t stripDisconnected=kTRUE) const ;	virtual RooArgSet* getAllConstraints(const RooArgSet& observables, RooArg Set& constrainedParams, Bool_t stripDisconnected=kTRUE) const ;

	// Project p.d.f into lower dimensional p.d.f	// Project p.d.f into lower dimensional p.d.f
	virtual RooAbsPdf* createProjection(const RooArgSet& iset) ;	virtual RooAbsPdf* createProjection(const RooArgSet& iset) ;

	// Create cumulative density function from p.d.f	// Create cumulative density function from p.d.f
	RooAbsReal* createCdf(const RooArgSet& iset, const RooArgSet& nset=RooArg Set()) ;	RooAbsReal* createCdf(const RooArgSet& iset, const RooArgSet& nset=RooArg Set()) ;

	RooAbsReal* createCdf(const RooArgSet& iset, const RooCmdArg arg1, const	RooAbsReal* createCdf(const RooArgSet& iset, const RooCmdArg& arg1, const
	RooCmdArg arg2=RooCmdArg::none(),	RooCmdArg& arg2=RooCmdArg::none(),
	const RooCmdArg arg3=RooCmdArg::none(), const RooCmd	const RooCmdArg& arg3=RooCmdArg::none(), const RooCm
	Arg arg4=RooCmdArg::none(),	dArg& arg4=RooCmdArg::none(),
	const RooCmdArg arg5=RooCmdArg::none(), const RooCmd	const RooCmdArg& arg5=RooCmdArg::none(), const RooCm
	Arg arg6=RooCmdArg::none(),	dArg& arg6=RooCmdArg::none(),
	const RooCmdArg arg7=RooCmdArg::none(), const RooCmd	const RooCmdArg& arg7=RooCmdArg::none(), const RooCm
	Arg arg8=RooCmdArg::none()) ;	dArg& arg8=RooCmdArg::none()) ;
	RooAbsReal* createScanCdf(const RooArgSet& iset, const RooArgSet& nset, I nt_t numScanBins, Int_t intOrder) ;	RooAbsReal* createScanCdf(const RooArgSet& iset, const RooArgSet& nset, I nt_t numScanBins, Int_t intOrder) ;

	// Function evaluation support	// Function evaluation support
	virtual Bool_t traceEvalHook(Double_t value) const ;	virtual Bool_t traceEvalHook(Double_t value) const ;
	virtual Double_t getVal(const RooArgSet* set=0) const ;	virtual Double_t getVal(const RooArgSet* set=0) const ;
	virtual Double_t getLogVal(const RooArgSet* set=0) const ;	virtual Double_t getLogVal(const RooArgSet* set=0) const ;

	void setNormValueCaching(Int_t minNumIntDim, Int_t ipOrder=2) ;	void setNormValueCaching(Int_t minNumIntDim, Int_t ipOrder=2) ;
	Int_t minDimNormValueCaching() const { return _minDimNormValueCache ; }	Int_t minDimNormValueCaching() const { return _minDimNormValueCache ; }
	Int_t intOrderNormValueCaching() const { return _valueCacheIntOrder ; }	Int_t intOrderNormValueCaching() const { return _valueCacheIntOrder ; }

End of changes. 6 change blocks.
	27 lines changed or deleted	34 lines changed or added

	RooAbsReal.h	RooAbsReal.h

	skipping to change at line 106	skipping to change at line 106
	// even if this is deemed unsafe. This default implementation returns a lways flase	// even if this is deemed unsafe. This default implementation returns a lways flase
	return kFALSE ;	return kFALSE ;
	}	}
	virtual void forceNumInt(Bool_t flag=kTRUE) {	virtual void forceNumInt(Bool_t flag=kTRUE) {
	// If flag is true, all advertised analytical integrals will be ignored	// If flag is true, all advertised analytical integrals will be ignored
	// and all integrals are calculated numerically	// and all integrals are calculated numerically
	_forceNumInt = flag ;	_forceNumInt = flag ;
	}	}

	// Chi^2 fits to histograms	// Chi^2 fits to histograms

	virtual RooFitResult* chi2FitTo(RooDataHist& data, RooCmdArg arg1=RooCmdA	virtual RooFitResult* chi2FitTo(RooDataHist& data, const RooCmdArg& arg1=
	rg::none(), RooCmdArg arg2=RooCmdArg::none(),	RooCmdArg::none(), const RooCmdArg& arg2=RooCmdArg::none(),
	RooCmdArg arg3=RooCmdArg::none(), RooCmdArg	const RooCmdArg& arg3=RooCmdArg::none(), con
	arg4=RooCmdArg::none(), RooCmdArg arg5=RooCmdArg::none(),	st RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5=RooCmdArg::none
	RooCmdArg arg6=RooCmdArg::none(), RooCmdArg	(),
	arg7=RooCmdArg::none(), RooCmdArg arg8=RooCmdArg::none()) ;	const RooCmdArg& arg6=RooCmdArg::none(), con
		st RooCmdArg& arg7=RooCmdArg::none(), const RooCmdArg& arg8=RooCmdArg::none
		()) ;
	virtual RooFitResult* chi2FitTo(RooDataHist& data, const RooLinkedList& c mdList) ;	virtual RooFitResult* chi2FitTo(RooDataHist& data, const RooLinkedList& c mdList) ;

	virtual RooAbsReal* createChi2(RooDataHist& data, const RooLinkedList& cm dList) ;	virtual RooAbsReal* createChi2(RooDataHist& data, const RooLinkedList& cm dList) ;

	virtual RooAbsReal* createChi2(RooDataHist& data, RooCmdArg arg1=RooCmdAr	virtual RooAbsReal* createChi2(RooDataHist& data, const RooCmdArg& arg1=R
	g::none(), RooCmdArg arg2=RooCmdArg::none(),	ooCmdArg::none(), const RooCmdArg& arg2=RooCmdArg::none(),
	RooCmdArg arg3=RooCmdArg::none(), RooCmdAr	const RooCmdArg& arg3=RooCmdArg::none(), c
	g arg4=RooCmdArg::none(), RooCmdArg arg5=RooCmdArg::none(),	onst RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5=RooCmdArg::no
	RooCmdArg arg6=RooCmdArg::none(), RooCmdAr	ne(),
	g arg7=RooCmdArg::none(), RooCmdArg arg8=RooCmdArg::none()) ;	const RooCmdArg& arg6=RooCmdArg::none(), c
		onst RooCmdArg& arg7=RooCmdArg::none(), const RooCmdArg& arg8=RooCmdArg::no
		ne()) ;

	// Chi^2 fits to X-Y datasets	// Chi^2 fits to X-Y datasets

	virtual RooFitResult* chi2FitTo(RooDataSet& xydata, RooCmdArg arg1=RooCmd	virtual RooFitResult* chi2FitTo(RooDataSet& xydata, const RooCmdArg& arg1
	Arg::none(), RooCmdArg arg2=RooCmdArg::none(),	=RooCmdArg::none(), const RooCmdArg& arg2=RooCmdArg::none(),
	RooCmdArg arg3=RooCmdArg::none(), RooCmdArg	const RooCmdArg& arg3=RooCmdArg::none(), con
	arg4=RooCmdArg::none(), RooCmdArg arg5=RooCmdArg::none(),	st RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5=RooCmdArg::none
	RooCmdArg arg6=RooCmdArg::none(), RooCmdArg	(),
	arg7=RooCmdArg::none(), RooCmdArg arg8=RooCmdArg::none()) ;	const RooCmdArg& arg6=RooCmdArg::none(), con
		st RooCmdArg& arg7=RooCmdArg::none(), const RooCmdArg& arg8=RooCmdArg::none
		()) ;
	virtual RooFitResult* chi2FitTo(RooDataSet& xydata, const RooLinkedList& cmdList) ;	virtual RooFitResult* chi2FitTo(RooDataSet& xydata, const RooLinkedList& cmdList) ;

	virtual RooAbsReal* createChi2(RooDataSet& data, const RooLinkedList& cmd List) ;	virtual RooAbsReal* createChi2(RooDataSet& data, const RooLinkedList& cmd List) ;

	virtual RooAbsReal* createChi2(RooDataSet& data, RooCmdArg arg1=RooCmdArg	virtual RooAbsReal* createChi2(RooDataSet& data, const RooCmdArg& arg1=Ro
	::none(), RooCmdArg arg2=RooCmdArg::none(),	oCmdArg::none(), const RooCmdArg& arg2=RooCmdArg::none(),
	RooCmdArg arg3=RooCmdArg::none(), RooCmd	const RooCmdArg& arg3=RooCmdArg::none(),
	Arg arg4=RooCmdArg::none(), RooCmdArg arg5=RooCmdArg::none(),	const RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5=RooCmdArg::
	RooCmdArg arg6=RooCmdArg::none(), RooCmd	none(),
	Arg arg7=RooCmdArg::none(), RooCmdArg arg8=RooCmdArg::none()) ;	const RooCmdArg& arg6=RooCmdArg::none(),
		const RooCmdArg& arg7=RooCmdArg::none(), const RooCmdArg& arg8=RooCmdArg::
		none()) ;

	virtual RooAbsReal* createProfile(const RooArgSet& paramsOfInterest) ;	virtual RooAbsReal* createProfile(const RooArgSet& paramsOfInterest) ;


	RooAbsReal* createIntegral(const RooArgSet& iset, const RooCmdArg arg1, c	RooAbsReal* createIntegral(const RooArgSet& iset, const RooCmdArg& arg1,
	onst RooCmdArg arg2=RooCmdArg::none(),	const RooCmdArg& arg2=RooCmdArg::none(),
	const RooCmdArg arg3=RooCmdArg::none(), const	const RooCmdArg& arg3=RooCmdArg::none(), const
	RooCmdArg arg4=RooCmdArg::none(),	RooCmdArg& arg4=RooCmdArg::none(),
	const RooCmdArg arg5=RooCmdArg::none(), const R	const RooCmdArg& arg5=RooCmdArg::none(), const
	ooCmdArg arg6=RooCmdArg::none(),	RooCmdArg& arg6=RooCmdArg::none(),
	const RooCmdArg arg7=RooCmdArg::none(), const R	const RooCmdArg& arg7=RooCmdArg::none(), const
	ooCmdArg arg8=RooCmdArg::none()) const ;	RooCmdArg& arg8=RooCmdArg::none()) const ;

	RooAbsReal* createIntegral(const RooArgSet& iset, const char* rangeName) const {	RooAbsReal* createIntegral(const RooArgSet& iset, const char* rangeName) const {
	// Create integral over observables in iset in range named rangeName	// Create integral over observables in iset in range named rangeName
	return createIntegral(iset,0,0,rangeName) ;	return createIntegral(iset,0,0,rangeName) ;
	}	}
	RooAbsReal* createIntegral(const RooArgSet& iset, const RooArgSet& nset, const char* rangeName=0) const {	RooAbsReal* createIntegral(const RooArgSet& iset, const RooArgSet& nset, const char* rangeName=0) const {
	// Create integral over observables in iset in range named rangeName wi th integrand normalized over observables in nset	// Create integral over observables in iset in range named rangeName wi th integrand normalized over observables in nset
	return createIntegral(iset,&nset,0,rangeName) ;	return createIntegral(iset,&nset,0,rangeName) ;
	}	}
	RooAbsReal* createIntegral(const RooArgSet& iset, const RooArgSet& nset, const RooNumIntConfig& cfg, const char* rangeName=0) const {	RooAbsReal* createIntegral(const RooArgSet& iset, const RooArgSet& nset, const RooNumIntConfig& cfg, const char* rangeName=0) const {

	skipping to change at line 155	skipping to change at line 155
	return createIntegral(iset,&nset,&cfg,rangeName) ;	return createIntegral(iset,&nset,&cfg,rangeName) ;
	}	}
	RooAbsReal* createIntegral(const RooArgSet& iset, const RooNumIntConfig& cfg, const char* rangeName=0) const {	RooAbsReal* createIntegral(const RooArgSet& iset, const RooNumIntConfig& cfg, const char* rangeName=0) const {
	// Create integral over observables in iset in range named rangeName us ing specified configuration for any numeric integration	// Create integral over observables in iset in range named rangeName us ing specified configuration for any numeric integration
	return createIntegral(iset,0,&cfg,rangeName) ;	return createIntegral(iset,0,&cfg,rangeName) ;
	}	}
	virtual RooAbsReal* createIntegral(const RooArgSet& iset, const RooArgSet * nset=0, const RooNumIntConfig* cfg=0, const char* rangeName=0) const ;	virtual RooAbsReal* createIntegral(const RooArgSet& iset, const RooArgSet * nset=0, const RooNumIntConfig* cfg=0, const char* rangeName=0) const ;

	// Create running integrals	// Create running integrals
	RooAbsReal* createRunningIntegral(const RooArgSet& iset, const RooArgSet& nset=RooArgSet()) ;	RooAbsReal* createRunningIntegral(const RooArgSet& iset, const RooArgSet& nset=RooArgSet()) ;

	RooAbsReal* createRunningIntegral(const RooArgSet& iset, const RooCmdArg	RooAbsReal* createRunningIntegral(const RooArgSet& iset, const RooCmdArg&
	arg1, const RooCmdArg arg2=RooCmdArg::none(),	arg1, const RooCmdArg& arg2=RooCmdArg::none(),
	const RooCmdArg arg3=RooCmdArg::none(), const RooCmd	const RooCmdArg& arg3=RooCmdArg::none(), const RooCm
	Arg arg4=RooCmdArg::none(),	dArg& arg4=RooCmdArg::none(),
	const RooCmdArg arg5=RooCmdArg::none(), const RooCmd	const RooCmdArg& arg5=RooCmdArg::none(), const RooCm
	Arg arg6=RooCmdArg::none(),	dArg& arg6=RooCmdArg::none(),
	const RooCmdArg arg7=RooCmdArg::none(), const RooCmd	const RooCmdArg& arg7=RooCmdArg::none(), const RooCm
	Arg arg8=RooCmdArg::none()) ;	dArg& arg8=RooCmdArg::none()) ;
	RooAbsReal* createIntRI(const RooArgSet& iset, const RooArgSet& nset=RooA rgSet()) ;	RooAbsReal* createIntRI(const RooArgSet& iset, const RooArgSet& nset=RooA rgSet()) ;
	RooAbsReal* createScanRI(const RooArgSet& iset, const RooArgSet& nset, In t_t numScanBins, Int_t intOrder) ;	RooAbsReal* createScanRI(const RooArgSet& iset, const RooArgSet& nset, In t_t numScanBins, Int_t intOrder) ;

	// Optimized accept/reject generator support	// Optimized accept/reject generator support
	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 Int_t minTrialSamples(const RooArgSet& /arGenObs/) const { retu rn 0 ; }	virtual Int_t minTrialSamples(const RooArgSet& /arGenObs/) const { retu rn 0 ; }

	// Plotting options	// Plotting options
	void setPlotLabel(const char *label);	void setPlotLabel(const char *label);

	skipping to change at line 236	skipping to change at line 236
	// Printing interface (human readable)	// Printing interface (human readable)
	virtual void printValue(ostream& os) const ;	virtual void printValue(ostream& os) const ;
	virtual void printMultiline(ostream& os, Int_t contents, Bool_t verbose=k FALSE, TString indent="") const ;	virtual void printMultiline(ostream& os, Int_t contents, Bool_t verbose=k FALSE, TString indent="") const ;

	static void setCacheCheck(Bool_t flag) ;	static void setCacheCheck(Bool_t flag) ;

	// Evaluation error logging	// Evaluation error logging
	class EvalError {	class EvalError {
	public:	public:
	EvalError() { _msg[0] = 0 ; _srvval[0] = 0 ; }	EvalError() { _msg[0] = 0 ; _srvval[0] = 0 ; }

	EvalError(const EvalError& other) { strcpy(_msg,other._msg) ; strcpy(_s rvval,other._srvval) ; } ;	EvalError(const EvalError& other) { strlcpy(_msg,other._msg,1024) ; str lcpy(_srvval,other._srvval,1024) ; } ;
	void setMessage(const char* tmp) ;	void setMessage(const char* tmp) ;
	void setServerValues(const char* tmp) ;	void setServerValues(const char* tmp) ;
	char _msg[1024] ;	char _msg[1024] ;
	char _srvval[1024] ;	char _srvval[1024] ;
	} ;	} ;

	enum ErrorLoggingMode { PrintErrors, CollectErrors, CountErrors } ;	enum ErrorLoggingMode { PrintErrors, CollectErrors, CountErrors } ;
	static ErrorLoggingMode evalErrorLoggingMode() ;	static ErrorLoggingMode evalErrorLoggingMode() ;
	static void setEvalErrorLoggingMode(ErrorLoggingMode m) ;	static void setEvalErrorLoggingMode(ErrorLoggingMode m) ;
	void logEvalError(const char* message, const char* serverValueString=0) c onst ;	void logEvalError(const char* message, const char* serverValueString=0) c onst ;

	skipping to change at line 361	skipping to change at line 361
	Double_t _plotMax ; // Maximum of plot range	Double_t _plotMax ; // Maximum of plot range
	Int_t _plotBins ; // Number of plot bins	Int_t _plotBins ; // Number of plot bins
	mutable Double_t _value ; // Cache for current value of object	mutable Double_t _value ; // Cache for current value of object
	TString _unit ; // Unit for objects value	TString _unit ; // Unit for objects value
	TString _label ; // Plot label for objects value	TString _label ; // Plot label for objects value
	Bool_t _forceNumInt ; // Force numerical integration if flag set	Bool_t _forceNumInt ; // Force numerical integration if flag set

	mutable Float_t _floatValue ; //! Transient cache for floating point valu es from tree branches	mutable Float_t _floatValue ; //! Transient cache for floating point valu es from tree branches
	mutable Int_t _intValue ; //! Transient cache for integer values from tree branches	mutable Int_t _intValue ; //! Transient cache for integer values from tree branches
	mutable UChar_t _byteValue ; //! Transient cache for byte values from tr ee branches	mutable UChar_t _byteValue ; //! Transient cache for byte values from tr ee branches

		mutable Char_t _sbyteValue ; //! Transient cache for signed byte values from tree branches
	mutable UInt_t _uintValue ; //! Transient cache for unsigned integer va lues from tree branches	mutable UInt_t _uintValue ; //! Transient cache for unsigned integer va lues from tree branches

	friend class RooAbsPdf ;	friend class RooAbsPdf ;
	friend class RooAbsAnaConvPdf ;	friend class RooAbsAnaConvPdf ;
	friend class RooRealProxy ;	friend class RooRealProxy ;

	RooNumIntConfig* _specIntegratorConfig ; // Numeric integrator configurat ion specific for this object	RooNumIntConfig* _specIntegratorConfig ; // Numeric integrator configurat ion specific for this object

	Bool_t _treeVar ; // !do not persist	Bool_t _treeVar ; // !do not persist


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

	RooAcceptReject.h	RooAcceptReject.h

	skipping to change at line 31	skipping to change at line 31
	#include "RooArgSet.h"	#include "RooArgSet.h"

	class RooAbsReal;	class RooAbsReal;
	class RooRealVar;	class RooRealVar;
	class RooDataSet;	class RooDataSet;
	class RooRealBinding;	class RooRealBinding;
	class RooNumGenFactory ;	class RooNumGenFactory ;

	class RooAcceptReject : public RooAbsNumGenerator {	class RooAcceptReject : public RooAbsNumGenerator {
	public:	public:

	RooAcceptReject() : _nextCatVar(0), _nextRealVar(0) {} ;	RooAcceptReject() : _nextCatVar(0), _nextRealVar(0) {
		// coverity[UNINIT_CTOR]
		} ;
	RooAcceptReject(const RooAbsReal &func, const RooArgSet &genVars, const R ooNumGenConfig& config, Bool_t verbose=kFALSE, const RooAbsReal* maxFuncVal =0);	RooAcceptReject(const RooAbsReal &func, const RooArgSet &genVars, const R ooNumGenConfig& config, Bool_t verbose=kFALSE, const RooAbsReal* maxFuncVal =0);
	RooAbsNumGenerator* clone(const RooAbsReal& func, const RooArgSet& genVar s, const RooArgSet& /condVars/,	RooAbsNumGenerator* clone(const RooAbsReal& func, const RooArgSet& genVar s, const RooArgSet& /condVars/,
	const RooNumGenConfig& config, Bool_t verbose=kF ALSE, const RooAbsReal* maxFuncVal=0) const {	const RooNumGenConfig& config, Bool_t verbose=kF ALSE, const RooAbsReal* maxFuncVal=0) const {
	return new RooAcceptReject(func,genVars,config,verbose,maxFuncVal) ;	return new RooAcceptReject(func,genVars,config,verbose,maxFuncVal) ;
	}	}
	virtual ~RooAcceptReject();	virtual ~RooAcceptReject();

	const RooArgSet *generateEvent(UInt_t remaining, Double_t& resampleRatio) ;	const RooArgSet *generateEvent(UInt_t remaining, Double_t& resampleRatio) ;
	Double_t getFuncMax() ;	Double_t getFuncMax() ;


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

	RooAddModel.h	RooAddModel.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_ADD_MODEL	#ifndef ROO_ADD_MODEL
	#define ROO_ADD_MODEL	#define ROO_ADD_MODEL

	#include "RooResolutionModel.h"	#include "RooResolutionModel.h"
	#include "RooListProxy.h"	#include "RooListProxy.h"

		#include "RooSetProxy.h"
	#include "RooAICRegistry.h"	#include "RooAICRegistry.h"
	#include "RooNormSetCache.h"	#include "RooNormSetCache.h"
	#include "RooNameSet.h"	#include "RooNameSet.h"
	#include "RooCacheManager.h"	#include "RooCacheManager.h"
	#include "RooObjCacheManager.h"	#include "RooObjCacheManager.h"

	class RooAddModel : public RooResolutionModel {	class RooAddModel : public RooResolutionModel {
	public:	public:

	RooAddModel() ;	RooAddModel() ;

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

	RooAddPdf.h	RooAddPdf.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_ADD_PDF	#ifndef ROO_ADD_PDF
	#define ROO_ADD_PDF	#define ROO_ADD_PDF

	#include "RooAbsPdf.h"	#include "RooAbsPdf.h"
	#include "RooListProxy.h"	#include "RooListProxy.h"

		#include "RooSetProxy.h"
	#include "RooAICRegistry.h"	#include "RooAICRegistry.h"
	#include "RooNormSetCache.h"	#include "RooNormSetCache.h"
	#include "RooNameSet.h"	#include "RooNameSet.h"
	#include "RooCacheManager.h"	#include "RooCacheManager.h"
	#include "RooObjCacheManager.h"	#include "RooObjCacheManager.h"
	#include "RooNameReg.h"	#include "RooNameReg.h"

	class RooAddPdf : public RooAbsPdf {	class RooAddPdf : public RooAbsPdf {
	public:	public:


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

	RooAddition.h	RooAddition.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_ADDITION	#ifndef ROO_ADDITION
	#define ROO_ADDITION	#define ROO_ADDITION

	#include "RooAbsReal.h"	#include "RooAbsReal.h"
	#include "RooListProxy.h"	#include "RooListProxy.h"

		#include "RooObjCacheManager.h"

	class RooRealVar;	class RooRealVar;
	class RooArgList ;	class RooArgList ;

	class RooAddition : public RooAbsReal {	class RooAddition : public RooAbsReal {
	public:	public:

	RooAddition() ;	RooAddition() ;
	RooAddition(const char name, const char title, const RooArgSet& sumSet, Bool_t takeOwnerShip=kFALSE) ;	RooAddition(const char name, const char title, const RooArgSet& sumSet, Bool_t takeOwnerShip=kFALSE) ;
	RooAddition(const char name, const char title, const RooArgList& sumSet 1, const RooArgList& sumSet2, Bool_t takeOwnerShip=kFALSE) ;	RooAddition(const char name, const char title, const RooArgList& sumSet 1, const RooArgList& sumSet2, Bool_t takeOwnerShip=kFALSE) ;
	virtual ~RooAddition() ;	virtual ~RooAddition() ;

	RooAddition(const RooAddition& other, const char* name = 0);	RooAddition(const RooAddition& other, const char* name = 0);
	virtual TObject* clone(const char* newname) const { return new RooAdditio n(*this, newname); }	virtual TObject* clone(const char* newname) const { return new RooAdditio n(*this, newname); }

	virtual Double_t defaultErrorLevel() const ;	virtual Double_t defaultErrorLevel() const ;

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


	const RooArgList& list1() const { return _set1 ; }	const RooArgList& list1() const { return _set ; }
	const RooArgList& list2() const { return _set2 ; }	const RooArgList& list() const { return _set ; }

		virtual Bool_t forceAnalyticalInt(const RooAbsArg& /dep/) const {
		// Force RooRealIntegral to offer all observables for internal integr
		ation
		return kTRUE ;
		}
		Int_t getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& numVars, const
		char* rangeName=0) const;
		Double_t analyticalIntegral(Int_t code, const char* rangeName=0) const ;

	protected:	protected:


	RooArgList _ownedList ; // List of owned components	RooArgList _ownedList ; // List of owned components
	RooListProxy _set1 ; // First set of terms to be summed	RooListProxy _set ; // set of terms to be summed
	RooListProxy _set2 ; // Second set of terms to be summed	mutable TIterator* _setIter ; //! Iterator over set
	mutable TIterator* _setIter1 ; //! Iterator over set1
	mutable TIterator* _setIter2 ; //! Iterator over set2	class CacheElem : public RooAbsCacheElement {
		public:
		virtual ~CacheElem();
		// Payload
		RooArgList _I ;
		virtual RooArgList containedArgs(Action) ;
		};
		mutable RooObjCacheManager _cacheMgr ; // The cache manager

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


	ClassDef(RooAddition,1) // Sum of RooAbsReal objects	ClassDef(RooAddition,2) // Sum of RooAbsReal objects
	};	};

	#endif	#endif

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

	RooArgProxy.h	RooArgProxy.h

	skipping to change at line 27	skipping to change at line 27
	#define ROO_ARG_PROXY	#define ROO_ARG_PROXY

	#include "TNamed.h"	#include "TNamed.h"
	#include "RooAbsProxy.h"	#include "RooAbsProxy.h"
	#include "RooAbsArg.h"	#include "RooAbsArg.h"

	class RooArgProxy : public TNamed, public RooAbsProxy {	class RooArgProxy : public TNamed, public RooAbsProxy {
	public:	public:

	// Constructors, assignment etc.	// Constructors, assignment etc.

	RooArgProxy() : _owner(0), _arg(0), _ownArg(kFALSE) {	RooArgProxy() : _owner(0), _arg(0), _valueServer(kFALSE), _shapeServer(kF ALSE), _isFund(kTRUE), _ownArg(kFALSE) {
	// Default constructor	// Default constructor
	} ;	} ;
	RooArgProxy(const char* name, const char* desc, RooAbsArg* owner,	RooArgProxy(const char* name, const char* desc, RooAbsArg* owner,
	Bool_t valueServer, Bool_t shapeServer, Bool_t proxyOwnsArg=kF ALSE) ;	Bool_t valueServer, Bool_t shapeServer, Bool_t proxyOwnsArg=kF ALSE) ;
	RooArgProxy(const char* name, const char* desc, RooAbsArg* owner, RooAbsA rg& arg,	RooArgProxy(const char* name, const char* desc, RooAbsArg* owner, RooAbsA rg& arg,
	Bool_t valueServer, Bool_t shapeServer, Bool_t proxyOwnsArg=kF ALSE) ;	Bool_t valueServer, Bool_t shapeServer, Bool_t proxyOwnsArg=kF ALSE) ;
	RooArgProxy(const char* name, RooAbsArg* owner, const RooArgProxy& other) ;	RooArgProxy(const char* name, RooAbsArg* owner, const RooArgProxy& other) ;
	virtual ~RooArgProxy() ;	virtual ~RooArgProxy() ;
	inline RooAbsArg* absArg() const {	inline RooAbsArg* absArg() const {
	// Return pointer to contained argument	// Return pointer to contained argument

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

	RooCFunction1Binding.h	RooCFunction1Binding.h
	/************************************************************************ *	/************************************************************************ *
	* Project: RooFit *	* Project: RooFit *
	* Package: RooFitCore *	* Package: RooFitCore *

	* File: $Id: RooCFunction1Binding.h 35299 2010-09-15 12:51:24Z pcanal $	* File: $Id: RooCFunction1Binding.h 36207 2010-10-08 19:00:29Z wouter $
	* Authors: *	* Authors: *
	* WV, Wouter Verkerke, NIKHEF, verkerke@nikhef.nl *	* WV, Wouter Verkerke, NIKHEF, verkerke@nikhef.nl *
	* *	* *
	* Copyright (c) 2000-2008, NIKHEF, Regents of the University of California *	* Copyright (c) 2000-2008, NIKHEF, Regents of the University of California *
	* and Stanford University. All rights reserved. *	* and Stanford University. All rights reserved. *
	* *	* *
	************************************************************************ */	************************************************************************ */

	#ifndef ROOCFUNCTION1BINDING	#ifndef ROOCFUNCTION1BINDING
	#define ROOCFUNCTION1BINDING	#define ROOCFUNCTION1BINDING

	skipping to change at line 163	skipping to change at line 163
	// issues and a dummy null function is substituted. When the registered f unction	// issues and a dummy null function is substituted. When the registered f unction
	// name can not be mapped to a function pointer an ERROR is issued and a pointer	// name can not be mapped to a function pointer an ERROR is issued and a pointer
	// to the dummy null function is substituted	// to the dummy null function is substituted

	typedef ::RooCFunction1Ref<VO,VI> thisClass;	typedef ::RooCFunction1Ref<VO,VI> thisClass;

	// Stream an object of class RooCFunction1Ref	// Stream an object of class RooCFunction1Ref
	if (R__b.IsReading()) {	if (R__b.IsReading()) {

	UInt_t R__s, R__c;	UInt_t R__s, R__c;

	R__b.ReadVersion(&R__s, &R__c);	Version_t R__v = R__b.ReadVersion(&R__s, &R__c);

	// Read name from file	// Read name from file
	TString tmpName ;	TString tmpName ;
	tmpName.Streamer(R__b) ;	tmpName.Streamer(R__b) ;


	if (tmpName=="UNKNOWN") {	if (tmpName=="UNKNOWN" && R__v>0) {

	coutW(ObjectHandling) << "WARNING: Objected embeds function pointer to unknown function, object will not be functional" << endl ;	coutW(ObjectHandling) << "WARNING: Objected embeds function pointer to unknown function, object will not be functional" << endl ;
	_ptr = dummyFunction ;	_ptr = dummyFunction ;

	} else {	} else {

	// Lookup pointer to C function wih given name	// Lookup pointer to C function wih given name
	_ptr = fmap().lookupPtr(tmpName.Data()) ;	_ptr = fmap().lookupPtr(tmpName.Data()) ;

	if (_ptr==0) {	if (_ptr==0) {

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

	RooCFunction2Binding.h	RooCFunction2Binding.h
	/************************************************************************ *	/************************************************************************ *
	* Project: RooFit *	* Project: RooFit *
	* Package: RooFitCore *	* Package: RooFitCore *

	* File: $Id: RooCFunction2Binding.h 35299 2010-09-15 12:51:24Z pcanal $	* File: $Id: RooCFunction2Binding.h 36207 2010-10-08 19:00:29Z wouter $
	* Authors: *	* Authors: *
	* WV, Wouter Verkerke, NIKHEF, verkerke@nikhef.nl *	* WV, Wouter Verkerke, NIKHEF, verkerke@nikhef.nl *
	* *	* *
	* Copyright (c) 2000-2008, NIKHEF, Regents of the University of California *	* Copyright (c) 2000-2008, NIKHEF, Regents of the University of California *
	* and Stanford University. All rights reserved. *	* and Stanford University. All rights reserved. *
	* *	* *
	************************************************************************ */	************************************************************************ */

	#ifndef ROOCFUNCTION2BINDING	#ifndef ROOCFUNCTION2BINDING
	#define ROOCFUNCTION2BINDING	#define ROOCFUNCTION2BINDING

	skipping to change at line 173	skipping to change at line 173
	// issues and a dummy null function is substituted. When the registered f unction	// issues and a dummy null function is substituted. When the registered f unction
	// name can not be mapped to a function pointer an ERROR is issued and a pointer	// name can not be mapped to a function pointer an ERROR is issued and a pointer
	// to the dummy null function is substituted	// to the dummy null function is substituted

	typedef ::RooCFunction2Ref<VO,VI1,VI2> thisClass;	typedef ::RooCFunction2Ref<VO,VI1,VI2> thisClass;

	// Stream an object of class RooCFunction2Ref	// Stream an object of class RooCFunction2Ref
	if (R__b.IsReading()) {	if (R__b.IsReading()) {

	UInt_t R__s, R__c;	UInt_t R__s, R__c;

	R__b.ReadVersion(&R__s, &R__c);	Version_t R__v = R__b.ReadVersion(&R__s, &R__c);

	// Read name from file	// Read name from file
	TString tmpName ;	TString tmpName ;
	tmpName.Streamer(R__b) ;	tmpName.Streamer(R__b) ;


	if (tmpName=="UNKNOWN") {	if (tmpName=="UNKNOWN" && R__v>0) {

	coutW(ObjectHandling) << "WARNING: Objected embeds function pointer to unknown function, object will not be functional" << endl ;	coutW(ObjectHandling) << "WARNING: Objected embeds function pointer to unknown function, object will not be functional" << endl ;
	_ptr = dummyFunction ;	_ptr = dummyFunction ;

	} else {	} else {

	// Lookup pointer to C function wih given name	// Lookup pointer to C function wih given name
	_ptr = fmap().lookupPtr(tmpName.Data()) ;	_ptr = fmap().lookupPtr(tmpName.Data()) ;

	if (_ptr==0) {	if (_ptr==0) {

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

	RooCFunction3Binding.h	RooCFunction3Binding.h
	/************************************************************************ *	/************************************************************************ *
	* Project: RooFit *	* Project: RooFit *
	* Package: RooFitCore *	* Package: RooFitCore *

	* File: $Id: RooCFunction3Binding.h 35299 2010-09-15 12:51:24Z pcanal $	* File: $Id: RooCFunction3Binding.h 36207 2010-10-08 19:00:29Z wouter $
	* Authors: * WV, Wouter Verkerke, NIKHEF, verkerke@nikhef.nl *	* Authors: * WV, Wouter Verkerke, NIKHEF, verkerke@nikhef.nl *
	* *	* *
	* Copyright (c) 2000-2008, NIKHEF, Regents of the University of California *	* Copyright (c) 2000-2008, NIKHEF, Regents of the University of California *
	* and Stanford University. All rights reserved. *	* and Stanford University. All rights reserved. *
	* *	* *
	************************************************************************ */	************************************************************************ */

	#ifndef ROOCFUNCTION3BINDING	#ifndef ROOCFUNCTION3BINDING
	#define ROOCFUNCTION3BINDING	#define ROOCFUNCTION3BINDING


	skipping to change at line 176	skipping to change at line 176
	// issues and a dummy null function is substituted. When the registered f unction	// issues and a dummy null function is substituted. When the registered f unction
	// name can not be mapped to a function pointer an ERROR is issued and a pointer	// name can not be mapped to a function pointer an ERROR is issued and a pointer
	// to the dummy null function is substituted	// to the dummy null function is substituted

	typedef ::RooCFunction3Ref<VO,VI1,VI2,VI3> thisClass;	typedef ::RooCFunction3Ref<VO,VI1,VI2,VI3> thisClass;

	// Stream an object of class RooCFunction3Ref	// Stream an object of class RooCFunction3Ref
	if (R__b.IsReading()) {	if (R__b.IsReading()) {

	UInt_t R__s, R__c;	UInt_t R__s, R__c;

	R__b.ReadVersion(&R__s, &R__c);	Version_t R__v = R__b.ReadVersion(&R__s, &R__c);

	// Read name from file	// Read name from file
	TString tmpName ;	TString tmpName ;
	tmpName.Streamer(R__b) ;	tmpName.Streamer(R__b) ;


	if (tmpName=="UNKNOWN") {	if (tmpName=="UNKNOWN" && R__v>0) {

	coutW(ObjectHandling) << "WARNING: Objected embeds function pointer to unknown function, object will not be functional" << endl ;	coutW(ObjectHandling) << "WARNING: Objected embeds function pointer to unknown function, object will not be functional" << endl ;
	_ptr = dummyFunction ;	_ptr = dummyFunction ;

	} else {	} else {

	// Lookup pointer to C function wih given name	// Lookup pointer to C function wih given name
	_ptr = fmap().lookupPtr(tmpName.Data()) ;	_ptr = fmap().lookupPtr(tmpName.Data()) ;

	if (_ptr==0) {	if (_ptr==0) {

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

	RooCFunction4Binding.h	RooCFunction4Binding.h
	/************************************************************************ *	/************************************************************************ *
	* Project: RooFit *	* Project: RooFit *
	* Package: RooFitCore *	* Package: RooFitCore *

	* File: $Id: RooCFunction4Binding.h 35299 2010-09-15 12:51:24Z pcanal $	* File: $Id: RooCFunction4Binding.h 36207 2010-10-08 19:00:29Z wouter $
	* Authors: *	* Authors: *
	* WV, Wouter Verkerke, NIKHEF, verkerke@nikhef.nl *	* WV, Wouter Verkerke, NIKHEF, verkerke@nikhef.nl *
	* *	* *
	* Copyright (c) 2000-2008, NIKHEF, Regents of the University of California *	* Copyright (c) 2000-2008, NIKHEF, Regents of the University of California *
	* and Stanford University. All rights reserved. *	* and Stanford University. All rights reserved. *
	* *	* *
	************************************************************************ */	************************************************************************ */

	#ifndef ROOCFUNCTION4BINDING	#ifndef ROOCFUNCTION4BINDING
	#define ROOCFUNCTION4BINDING	#define ROOCFUNCTION4BINDING

	skipping to change at line 170	skipping to change at line 170
	// issues and a dummy null function is substituted. When the registered f unction	// issues and a dummy null function is substituted. When the registered f unction
	// name can not be mapped to a function pointer an ERROR is issued and a pointer	// name can not be mapped to a function pointer an ERROR is issued and a pointer
	// to the dummy null function is substituted	// to the dummy null function is substituted

	typedef ::RooCFunction4Ref<VO,VI1,VI2,VI3,VI4> thisClass;	typedef ::RooCFunction4Ref<VO,VI1,VI2,VI3,VI4> thisClass;

	// Stream an object of class RooCFunction4Ref	// Stream an object of class RooCFunction4Ref
	if (R__b.IsReading()) {	if (R__b.IsReading()) {

	UInt_t R__s, R__c;	UInt_t R__s, R__c;

	R__b.ReadVersion(&R__s, &R__c);	Version_t R__v = R__b.ReadVersion(&R__s, &R__c);

	// Read name from file	// Read name from file
	TString tmpName ;	TString tmpName ;
	tmpName.Streamer(R__b) ;	tmpName.Streamer(R__b) ;


	if (tmpName=="UNKNOWN") {	if (tmpName=="UNKNOWN" && R__v>0) {

	coutW(ObjectHandling) << "WARNING: Objected embeds function pointer to unknown function, object will not be functional" << endl ;	coutW(ObjectHandling) << "WARNING: Objected embeds function pointer to unknown function, object will not be functional" << endl ;
	_ptr = dummyFunction ;	_ptr = dummyFunction ;

	} else {	} else {

	// Lookup pointer to C function wih given name	// Lookup pointer to C function wih given name
	_ptr = fmap().lookupPtr(tmpName.Data()) ;	_ptr = fmap().lookupPtr(tmpName.Data()) ;

	if (_ptr==0) {	if (_ptr==0) {

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

	RooCachedReal.h	RooCachedReal.h

	skipping to change at line 21	skipping to change at line 21

	#ifndef ROOCACHEDREAL	#ifndef ROOCACHEDREAL
	#define ROOCACHEDREAL	#define ROOCACHEDREAL

	#include "RooAbsCachedReal.h"	#include "RooAbsCachedReal.h"
	#include "RooRealProxy.h"	#include "RooRealProxy.h"
	#include "RooAbsReal.h"	#include "RooAbsReal.h"

	class RooCachedReal : public RooAbsCachedReal {	class RooCachedReal : public RooAbsCachedReal {
	public:	public:

	RooCachedReal() {}	RooCachedReal() {
		// coverity[UNINIT_CTOR]
		}
	RooCachedReal(const char name, const char title, RooAbsReal& _func, con st RooArgSet& cacheObs);	RooCachedReal(const char name, const char title, RooAbsReal& _func, con st RooArgSet& cacheObs);
	RooCachedReal(const char name, const char title, RooAbsReal& _func);	RooCachedReal(const char name, const char title, RooAbsReal& _func);
	RooCachedReal(const RooCachedReal& other, const char* name=0) ;	RooCachedReal(const RooCachedReal& other, const char* name=0) ;
	virtual TObject* clone(const char* newname) const { return new RooCachedR eal(*this,newname); }	virtual TObject* clone(const char* newname) const { return new RooCachedR eal(*this,newname); }
	virtual ~RooCachedReal() ;	virtual ~RooCachedReal() ;

	void setCdfBoundaries(Bool_t flag) {	void setCdfBoundaries(Bool_t flag) {
	// If flag is true the RooHistFunc that represent the cache histogram	// If flag is true the RooHistFunc that represent the cache histogram
	// will use special boundary conditions for use with cumulative distrib ution	// will use special boundary conditions for use with cumulative distrib ution
	// functions: at the lower bound the function is forced to converge at zero and the upper	// functions: at the lower bound the function is forced to converge at zero and the upper

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

	RooCatType.h	RooCatType.h

	skipping to change at line 37	skipping to change at line 37
	_value = 0 ; _label[0] = 0 ;	_value = 0 ; _label[0] = 0 ;
	}	}

	inline RooCatType(const char* name, Int_t value) : TObject(), RooPrintabl e(), _value(value) {	inline RooCatType(const char* name, Int_t value) : TObject(), RooPrintabl e(), _value(value) {
	// Constructor with state name and index value	// Constructor with state name and index value
	SetName(name) ;	SetName(name) ;
	}	}
	inline RooCatType(const RooCatType& other) :	inline RooCatType(const RooCatType& other) :
	TObject(other), RooPrintable(other), _value(other._value) {	TObject(other), RooPrintable(other), _value(other._value) {
	// Copy constructor	// Copy constructor

	strcpy(_label,other._label) ;	strlcpy(_label,other._label,256) ;
	} ;	} ;

	virtual ~RooCatType() {	virtual ~RooCatType() {
	// Destructor	// Destructor
	} ;	} ;
	virtual TObject* Clone(const char) const { return new RooCatType(this); }	virtual TObject* Clone(const char) const { return new RooCatType(this); }

	virtual const Text_t* GetName() const {	virtual const Text_t* GetName() const {
	// Return state name	// Return state name
	return _label ;	return _label ;

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

	RooCmdArg.h	RooCmdArg.h

	skipping to change at line 40	skipping to change at line 40
	RooCmdArg();	RooCmdArg();
	RooCmdArg(const char* name,	RooCmdArg(const char* name,
	Int_t i1=0, Int_t i2=0,	Int_t i1=0, Int_t i2=0,
	Double_t d1=0, Double_t d2=0,	Double_t d1=0, Double_t d2=0,
	const char* s1=0, const char* s2=0,	const char* s1=0, const char* s2=0,
	const TObject* o1=0, const TObject* o2=0, const RooCmdArg* ca=0, const char* s3=0,	const TObject* o1=0, const TObject* o2=0, const RooCmdArg* ca=0, const char* s3=0,
	const RooArgSet* c1=0, const RooArgSet* c2=0) ;	const RooArgSet* c1=0, const RooArgSet* c2=0) ;
	RooCmdArg(const RooCmdArg& other) ;	RooCmdArg(const RooCmdArg& other) ;
	RooCmdArg& operator=(const RooCmdArg& other) ;	RooCmdArg& operator=(const RooCmdArg& other) ;
	void addArg(const RooCmdArg& arg) ;	void addArg(const RooCmdArg& arg) ;

	void setProcessRecArgs(Bool_t flag) {	void setProcessRecArgs(Bool_t flag, Bool_t prefix=kTRUE) {
	// If true flag this object as containing recursive arguments	// If true flag this object as containing recursive arguments
	_procSubArgs = flag ;	_procSubArgs = flag ;

		_prefixSubArgs = prefix ;
	}	}

	RooLinkedList& subArgs() {	RooLinkedList& subArgs() {
	// Return list of sub-arguments in this RooCmdArg	// Return list of sub-arguments in this RooCmdArg
	return _argList ;	return _argList ;
	}	}

	virtual TObject* Clone(const char* newName=0) const {	virtual TObject* Clone(const char* newName=0) const {
	RooCmdArg* newarg = new RooCmdArg(*this) ;	RooCmdArg* newarg = new RooCmdArg(*this) ;
	if (newName) { newarg->SetName(newName) ; }	if (newName) { newarg->SetName(newName) ; }

	skipping to change at line 115	skipping to change at line 116
	friend class RooAbsCollection ;	friend class RooAbsCollection ;

	// Payload	// Payload
	Double_t _d[2] ; // Payload doubles	Double_t _d[2] ; // Payload doubles
	Int_t _i[2] ; // Payload integers	Int_t _i[2] ; // Payload integers
	std::string _s[3] ; // Payload strings	std::string _s[3] ; // Payload strings
	TObject* _o[2] ; // Payload objects	TObject* _o[2] ; // Payload objects
	Bool_t _procSubArgs ; // If true argument requires recursive processing	Bool_t _procSubArgs ; // If true argument requires recursive processing
	RooArgSet* _c ; // Payload RooArgSets	RooArgSet* _c ; // Payload RooArgSets
	RooLinkedList _argList ; // Payload sub-arguments	RooLinkedList _argList ; // Payload sub-arguments

		Bool_t _prefixSubArgs ; // Prefix subarguments with container name?


	ClassDef(RooCmdArg,1) // Generic named argument container	ClassDef(RooCmdArg,2) // Generic named argument container
	};	};

	#endif	#endif

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

	RooDataHist.h	RooDataHist.h

	skipping to change at line 50	skipping to change at line 50
	public:	public:

	// Constructors, factory methods etc.	// Constructors, factory methods etc.
	RooDataHist() ;	RooDataHist() ;
	RooDataHist(const char name, const char title, const RooArgSet& vars, c onst char* binningName=0) ;	RooDataHist(const char name, const char title, const RooArgSet& vars, c onst char* binningName=0) ;
	RooDataHist(const char name, const char title, const RooArgSet& vars, c onst RooAbsData& data, Double_t initWgt=1.0) ;	RooDataHist(const char name, const char title, const RooArgSet& vars, c onst RooAbsData& data, Double_t initWgt=1.0) ;
	RooDataHist(const char name, const char title, const RooArgList& vars, const TH1* hist, Double_t initWgt=1.0) ;	RooDataHist(const char name, const char title, const RooArgList& vars, const TH1* hist, Double_t initWgt=1.0) ;
	RooDataHist(const char name, const char title, const RooArgList& vars, RooCategory& indexCat, std::map<std::string,TH1*> histMap, Double_t initWgt =1.0) ;	RooDataHist(const char name, const char title, const RooArgList& vars, RooCategory& indexCat, std::map<std::string,TH1*> histMap, Double_t initWgt =1.0) ;
	RooDataHist(const char name, const char title, const RooArgList& vars, RooCategory& indexCat, std::map<std::string,RooDataHist*> dhistMap, Double_ t wgt=1.0) ;	RooDataHist(const char name, const char title, const RooArgList& vars, RooCategory& indexCat, std::map<std::string,RooDataHist*> dhistMap, Double_ t wgt=1.0) ;
	//RooDataHist(const char name, const char title, const RooArgList& vars , Double_t initWgt=1.0) ;	//RooDataHist(const char name, const char title, const RooArgList& vars , Double_t initWgt=1.0) ;

	RooDataHist(const char name, const char title, const RooArgList& vars,	RooDataHist(const char name, const char title, const RooArgList& vars,
	RooCmdArg arg1, RooCmdArg arg2=RooCmdArg(), RooCmdArg arg3=RooCmdArg(),	const RooCmdArg& arg1, const RooCmdArg& arg2=RooCmdArg(), const RooCmdArg&
	RooCmdArg arg4=RooCmdArg(),RooCmdArg arg5=RooCmdArg(),RooCmdAr	arg3=RooCmdArg(),
	g arg6=RooCmdArg(),RooCmdArg arg7=RooCmdArg(),RooCmdArg arg8=RooCmdArg()) ;	const RooCmdArg& arg4=RooCmdArg(),const RooCmdArg& arg5=RooCmd
		Arg(),const RooCmdArg& arg6=RooCmdArg(),const RooCmdArg& arg7=RooCmdArg(),c
		onst RooCmdArg& arg8=RooCmdArg()) ;

	RooDataHist(const RooDataHist& other, const char* newname = 0) ;	RooDataHist(const RooDataHist& other, const char* newname = 0) ;
	virtual TObject* Clone(const char* newname=0) const { return new RooDataH ist(*this,newname?newname:GetName()) ; }	virtual TObject* Clone(const char* newname=0) const { return new RooDataH ist(*this,newname?newname:GetName()) ; }
	virtual ~RooDataHist() ;	virtual ~RooDataHist() ;

	virtual RooAbsData* emptyClone(const char* newName=0, const char* newTitl e=0, const RooArgSet*vars=0) const {	virtual RooAbsData* emptyClone(const char* newName=0, const char* newTitl e=0, const RooArgSet*vars=0) const {
	// Return empty clone of this RooDataHist	// Return empty clone of this RooDataHist
	return new RooDataHist(newName?newName:GetName(),newTitle?newTitle:GetT itle(),vars?vars:get()) ;	return new RooDataHist(newName?newName:GetName(),newTitle?newTitle:GetT itle(),vars?vars:get()) ;
	}	}


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

	RooDataSet.h	RooDataSet.h

	skipping to change at line 36	skipping to change at line 36
	class RooDataSet : public RooAbsData, public RooDirItem {	class RooDataSet : public RooAbsData, public RooDirItem {
	public:	public:

	// Constructors, factory methods etc.	// Constructors, factory methods etc.
	RooDataSet() ;	RooDataSet() ;

	// Empty constructor	// Empty constructor
	RooDataSet(const char name, const char title, const RooArgSet& vars, co nst char* wgtVarName=0) ;	RooDataSet(const char name, const char title, const RooArgSet& vars, co nst char* wgtVarName=0) ;

	// Universal constructor	// Universal constructor

	RooDataSet(const char* name, const char* title, const RooArgSet& vars, Ro	RooDataSet(const char* name, const char* title, const RooArgSet& vars, co
	oCmdArg arg1, RooCmdArg arg2=RooCmdArg(),	nst RooCmdArg& arg1, const RooCmdArg& arg2=RooCmdArg(),
	RooCmdArg arg3=RooCmdArg(), RooCmdArg arg4=RooCmdArg(),RooCmdAr	const RooCmdArg& arg3=RooCmdArg(), const RooCmdArg& arg4=RooCmd
	g arg5=RooCmdArg(),	Arg(),const RooCmdArg& arg5=RooCmdArg(),
	RooCmdArg arg6=RooCmdArg(),RooCmdArg arg7=RooCmdArg(),RooCmdArg	const RooCmdArg& arg6=RooCmdArg(),const RooCmdArg& arg7=RooCmdA
	arg8=RooCmdArg()) ;	rg(),const RooCmdArg& arg8=RooCmdArg()) ;

	// Constructor for subset of existing dataset	// Constructor for subset of existing dataset
	RooDataSet(const char name, const char title, RooDataSet *data, const R ooArgSet& vars,	RooDataSet(const char name, const char title, RooDataSet *data, const R ooArgSet& vars,
	const char cuts=0, const char wgtVarName=0);	const char cuts=0, const char wgtVarName=0);
	RooDataSet(const char name, const char title, RooDataSet *data, const R ooArgSet& vars,	RooDataSet(const char name, const char title, RooDataSet *data, const R ooArgSet& vars,
	const RooFormulaVar& cutVar, const char* wgtVarName=0) ;	const RooFormulaVar& cutVar, const char* wgtVarName=0) ;

	// Constructor importing data from external ROOT Tree	// Constructor importing data from external ROOT Tree
	RooDataSet(const char name, const char title, TTree *ntuple, const RooA rgSet& vars,	RooDataSet(const char name, const char title, TTree *ntuple, const RooA rgSet& vars,
	const char cuts=0, const char wgtVarName=0);	const char cuts=0, const char wgtVarName=0);

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

	RooDouble.h	RooDouble.h

	skipping to change at line 25	skipping to change at line 25
	************************************************************************ */	************************************************************************ */
	#ifndef ROO_DOUBLE	#ifndef ROO_DOUBLE
	#define ROO_DOUBLE	#define ROO_DOUBLE

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

	class RooDouble : public TNamed {	class RooDouble : public TNamed {
	public:	public:


	RooDouble() {	RooDouble() : _value(0) {
	// Default constructor	// Default constructor
	} ;	} ;
	RooDouble(Double_t value) ;	RooDouble(Double_t value) ;
	RooDouble(const RooDouble& other) : TNamed(other), _value(other._value) { }	RooDouble(const RooDouble& other) : TNamed(other), _value(other._value) { }
	virtual ~RooDouble() {	virtual ~RooDouble() {
	// Destructor	// Destructor
	} ;	} ;

	// Double_t cast operator	// Double_t cast operator
	inline operator Double_t() const {	inline operator Double_t() const {

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

	RooExpensiveObjectCache.h	RooExpensiveObjectCache.h
	/************************************************************************ *	/************************************************************************ *
	* Project: RooFit *	* Project: RooFit *
	* Package: RooFitCore *	* Package: RooFitCore *

	* File: $Id: RooExpensiveObjectCache.h 28259 2009-04-16 16:21:16Z woute r $	* File: $Id: RooExpensiveObjectCache.h 36209 2010-10-08 21:37:36Z woute r $
	* Authors: *	* Authors: *
	* WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *	* WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *
	* DK, David Kirkby, UC Irvine, dkirkby@uci.edu *	* DK, David Kirkby, UC Irvine, dkirkby@uci.edu *
	* *	* *
	* 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) *

	skipping to change at line 53	skipping to change at line 53
	static RooExpensiveObjectCache& instance() ;	static RooExpensiveObjectCache& instance() ;

	Int_t size() const { return _map.size() ; }	Int_t size() const { return _map.size() ; }

	static void cleanup() ;	static void cleanup() ;

	void print() const ;	void print() const ;

	class ExpensiveObject {	class ExpensiveObject {
	public:	public:

	ExpensiveObject() { _payload = 0 ; } ;	ExpensiveObject() { _uid = 0 ; _payload = 0 ; } ;
	ExpensiveObject(Int_t uid, const char* ownerName, TObject& payload, TIt erator* paramIter) ;	ExpensiveObject(Int_t uid, const char* ownerName, TObject& payload, TIt erator* paramIter) ;
	ExpensiveObject(Int_t uid, const ExpensiveObject& other) ;	ExpensiveObject(Int_t uid, const ExpensiveObject& other) ;
	virtual ~ExpensiveObject() ;	virtual ~ExpensiveObject() ;
	Bool_t matches(TClass* tc, const RooArgSet& params) ;	Bool_t matches(TClass* tc, const RooArgSet& params) ;

	Int_t uid() const { return _uid ; }	Int_t uid() const { return _uid ; }
	const TObject* payload() const { return _payload ; }	const TObject* payload() const { return _payload ; }
	TObject* payload() { return _payload ; }	TObject* payload() { return _payload ; }
	void setPayload(TObject* obj) { _payload = obj ; }	void setPayload(TObject* obj) { _payload = obj ; }
	const char* ownerName() const { return _ownerName.Data() ; }	const char* ownerName() const { return _ownerName.Data() ; }

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

	RooFFTConvPdf.h	RooFFTConvPdf.h

	skipping to change at line 28	skipping to change at line 28
	#include "RooAbsReal.h"	#include "RooAbsReal.h"
	#include "RooHistPdf.h"	#include "RooHistPdf.h"
	#include "TVirtualFFT.h"	#include "TVirtualFFT.h"
	class RooRealVar ;	class RooRealVar ;

	#include <map>	#include <map>

	class RooFFTConvPdf : public RooAbsCachedPdf {	class RooFFTConvPdf : public RooAbsCachedPdf {
	public:	public:


	RooFFTConvPdf() {} ;	RooFFTConvPdf() {
		// coverity[UNINIT_CTOR]
		} ;
	RooFFTConvPdf(const char name, const char title, RooRealVar& convVar, R ooAbsPdf& pdf1, RooAbsPdf& pdf2, Int_t ipOrder=2);	RooFFTConvPdf(const char name, const char title, RooRealVar& convVar, R ooAbsPdf& pdf1, RooAbsPdf& pdf2, Int_t ipOrder=2);
	RooFFTConvPdf(const char name, const char title, RooAbsReal& pdfConvVar , RooRealVar& convVar, RooAbsPdf& pdf1, RooAbsPdf& pdf2, Int_t ipOrder=2);	RooFFTConvPdf(const char name, const char title, RooAbsReal& pdfConvVar , RooRealVar& convVar, RooAbsPdf& pdf1, RooAbsPdf& pdf2, Int_t ipOrder=2);
	RooFFTConvPdf(const RooFFTConvPdf& other, const char* name=0) ;	RooFFTConvPdf(const RooFFTConvPdf& other, const char* name=0) ;
	virtual TObject* clone(const char* newname) const { return new RooFFTConv Pdf(*this,newname); }	virtual TObject* clone(const char* newname) const { return new RooFFTConv Pdf(*this,newname); }
	virtual ~RooFFTConvPdf() ;	virtual ~RooFFTConvPdf() ;

	void setShift(Double_t val1, Double_t val2) { _shift1 = val1 ; _shift2 = val2 ; }	void setShift(Double_t val1, Double_t val2) { _shift1 = val1 ; _shift2 = val2 ; }
	void setCacheObservables(const RooArgSet& obs) { _cacheObs.removeAll() ; _cacheObs.add(obs) ; }	void setCacheObservables(const RooArgSet& obs) { _cacheObs.removeAll() ; _cacheObs.add(obs) ; }
	const RooArgSet& cacheObservables() const { return _cacheObs ; }	const RooArgSet& cacheObservables() const { return _cacheObs ; }


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

	RooGenCategory.h	RooGenCategory.h

	skipping to change at line 33	skipping to change at line 33

	#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() {
	// Default constructor	// Default constructor

		// 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(ostream& os, Int_t content, Bool_t verbose=kF ALSE, TString indent= "") const ;	virtual void printMultiline(ostream& os, Int_t content, Bool_t verbose=kF ALSE, TString indent= "") const ;

	// I/O streaming interface (machine readable)	// I/O streaming interface (machine readable)

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

	RooGlobalFunc.h	RooGlobalFunc.h

	skipping to change at line 20	skipping to change at line 20
	* 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_GLOBAL_FUNC	#ifndef ROO_GLOBAL_FUNC
	#define ROO_GLOBAL_FUNC	#define ROO_GLOBAL_FUNC

	#include "RooCmdArg.h"	#include "RooCmdArg.h"

		#include <map>
		#include <string>
	//#include "RooDataHist.h"	//#include "RooDataHist.h"
	//#include "RooAbsPdf.h"	//#include "RooAbsPdf.h"
	//#include "RooRealConstant.h"	//#include "RooRealConstant.h"
	//#include "RooMsgService.h"	//#include "RooMsgService.h"

	class RooDataHist ;	class RooDataHist ;
	class RooDataSet ;	class RooDataSet ;
	class RooFitResult ;	class RooFitResult ;
	class RooAbsPdf ;	class RooAbsPdf ;
	class RooAbsRealLValue ;	class RooAbsRealLValue ;

	skipping to change at line 114	skipping to change at line 116
	RooCmdArg CutRange(const char* rangeName) ;	RooCmdArg CutRange(const char* rangeName) ;
	RooCmdArg XErrorSize(Double_t width) ;	RooCmdArg XErrorSize(Double_t width) ;
	RooCmdArg RefreshNorm() ;	RooCmdArg RefreshNorm() ;
	RooCmdArg Efficiency(const RooCategory& cat) ;	RooCmdArg Efficiency(const RooCategory& cat) ;
	RooCmdArg Rescale(Double_t factor) ;	RooCmdArg Rescale(Double_t factor) ;

	// RooDataHist::ctor arguments	// RooDataHist::ctor arguments
	RooCmdArg Weight(Double_t wgt) ;	RooCmdArg Weight(Double_t wgt) ;
	RooCmdArg Index(RooCategory& icat) ;	RooCmdArg Index(RooCategory& icat) ;
	RooCmdArg Import(const char* state, TH1& histo) ;	RooCmdArg Import(const char* state, TH1& histo) ;

		RooCmdArg Import(const std::map<std::string,TH1*>&) ;
	RooCmdArg Import(const char* state, RooDataHist& dhist) ;	RooCmdArg Import(const char* state, RooDataHist& dhist) ;

		RooCmdArg Import(const std::map<std::string,RooDataHist*>&) ;
	RooCmdArg Import(TH1& histo, Bool_t importDensity=kTRUE) ;	RooCmdArg Import(TH1& histo, Bool_t importDensity=kTRUE) ;

	// RooDataSet::ctor arguments	// RooDataSet::ctor arguments
	RooCmdArg WeightVar(const char* name) ;	RooCmdArg WeightVar(const char* name) ;
	RooCmdArg WeightVar(const RooRealVar& arg) ;	RooCmdArg WeightVar(const RooRealVar& arg) ;
	RooCmdArg Import(const char* state, RooDataSet& data) ;	RooCmdArg Import(const char* state, RooDataSet& data) ;

		RooCmdArg Import(const std::map<std::string,RooDataSet*>& ) ;
	RooCmdArg Link(const char* state, RooAbsData& data) ;	RooCmdArg Link(const char* state, RooAbsData& data) ;

		RooCmdArg Link(const std::map<std::string,RooAbsData*>&) ;
	RooCmdArg Import(RooDataSet& data) ;	RooCmdArg Import(RooDataSet& data) ;
	RooCmdArg Import(TTree& tree) ;	RooCmdArg Import(TTree& tree) ;
	RooCmdArg ImportFromFile(const char* fname, const char* tname) ;	RooCmdArg ImportFromFile(const char* fname, const char* tname) ;
	RooCmdArg StoreError(const RooArgSet& aset) ;	RooCmdArg StoreError(const RooArgSet& aset) ;
	RooCmdArg StoreAsymError(const RooArgSet& aset) ;	RooCmdArg StoreAsymError(const RooArgSet& aset) ;

	// RooChi2Var::ctor arguments	// RooChi2Var::ctor arguments
	RooCmdArg Extended(Bool_t flag=kTRUE) ;	RooCmdArg Extended(Bool_t flag=kTRUE) ;
	RooCmdArg DataError(Int_t) ;	RooCmdArg DataError(Int_t) ;
	RooCmdArg NumCPU(Int_t nCPU, Bool_t interleave=kFALSE) ;	RooCmdArg NumCPU(Int_t nCPU, Bool_t interleave=kFALSE) ;

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

	RooHistPdf.h	RooHistPdf.h
	/************************************************************************ *	/************************************************************************ *
	* Project: RooFit *	* Project: RooFit *
	* Package: RooFitCore *	* Package: RooFitCore *

	* File: $Id: RooHistPdf.h 30333 2009-09-21 15:39:17Z wouter $	* File: $Id: RooHistPdf.h 37219 2010-12-03 12:51:36Z wouter $
	* Authors: *	* Authors: *
	* WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *	* WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *
	* DK, David Kirkby, UC Irvine, dkirkby@uci.edu *	* DK, David Kirkby, UC Irvine, dkirkby@uci.edu *
	* *	* *
	* 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) *

	skipping to change at line 85	skipping to change at line 85

	virtual Bool_t selfNormalized() const { return _unitNorm ; }	virtual Bool_t selfNormalized() const { return _unitNorm ; }

	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>* 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 ;

	protected:	protected:


		Bool_t importWorkspaceHook(RooWorkspace& ws) ;

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

	RooArgSet _histObsList ; // List of observables defining dimensio ns of histogram	RooArgSet _histObsList ; // List of observables defining dimensio ns of histogram
	RooSetProxy _pdfObsList ; // List of observables mapped onto histo gram observables	RooSetProxy _pdfObsList ; // List of observables mapped onto histo gram observables
	RooDataHist* _dataHist ; // Unowned pointer to underlying histogram	RooDataHist* _dataHist ; // Unowned pointer to underlying histogram
	TIterator* _histObsIter ; //!	TIterator* _histObsIter ; //!
	TIterator* _pdfObsIter ; //!	TIterator* _pdfObsIter ; //!

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

	RooInt.h	RooInt.h

	skipping to change at line 25	skipping to change at line 25
	************************************************************************ */	************************************************************************ */
	#ifndef ROO_INT	#ifndef ROO_INT
	#define ROO_INT	#define ROO_INT

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

	class RooInt : public TNamed {	class RooInt : public TNamed {
	public:	public:


	RooInt() {} ;	RooInt() : _value(0) {} ;
	RooInt(Int_t value) : TNamed(), _value(value) {} ;	RooInt(Int_t value) : TNamed(), _value(value) {} ;
	RooInt(const RooInt& other) : TNamed(other), _value(other._value) {}	RooInt(const RooInt& other) : TNamed(other), _value(other._value) {}
	virtual ~RooInt() {} ;	virtual ~RooInt() {} ;

	// Double_t cast operator	// Double_t cast operator
	inline operator Int_t() const { return _value ; }	inline operator Int_t() const { return _value ; }
	RooInt& operator=(Int_t value) { _value = value ; return *this ; }	RooInt& operator=(Int_t value) { _value = value ; return *this ; }

	// Sorting interface ;	// Sorting interface ;
	Int_t Compare(const TObject* other) const ;	Int_t Compare(const TObject* other) const ;

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

	RooIntegralMorph.h	RooIntegralMorph.h

	skipping to change at line 26	skipping to change at line 26
	#include "RooRealProxy.h"	#include "RooRealProxy.h"
	#include "RooCategoryProxy.h"	#include "RooCategoryProxy.h"
	#include "RooAbsReal.h"	#include "RooAbsReal.h"
	#include "RooAbsCategory.h"	#include "RooAbsCategory.h"
	class RooBrentRootFinder ;	class RooBrentRootFinder ;

	class TH1D ;	class TH1D ;

	class RooIntegralMorph : public RooAbsCachedPdf {	class RooIntegralMorph : public RooAbsCachedPdf {
	public:	public:

	RooIntegralMorph() {} ;	RooIntegralMorph() {
		// coverity[UNINIT_CTOR]
		} ;
	RooIntegralMorph(const char name, const char title,	RooIntegralMorph(const char name, const char title,
	RooAbsReal& _pdf1,	RooAbsReal& _pdf1,
	RooAbsReal& _pdf2,	RooAbsReal& _pdf2,
	RooAbsReal& _x,	RooAbsReal& _x,
	RooAbsReal& _alpha, Bool_t cacheAlpha=kFALSE);	RooAbsReal& _alpha, Bool_t cacheAlpha=kFALSE);
	RooIntegralMorph(const RooIntegralMorph& other, const char* name=0) ;	RooIntegralMorph(const RooIntegralMorph& other, const char* name=0) ;
	virtual TObject* clone(const char* newname) const { return new RooIntegra lMorph(*this,newname); }	virtual TObject* clone(const char* newname) const { return new RooIntegra lMorph(*this,newname); }
	inline virtual ~RooIntegralMorph() { }	inline virtual ~RooIntegralMorph() { }

	Bool_t selfNormalized() const {	Bool_t selfNormalized() const {

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

	RooKeysPdf.h	RooKeysPdf.h

	skipping to change at line 51	skipping to change at line 51
	protected:	protected:

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

	private:	private:

	Double_t evaluateFull(Double_t x) const;	Double_t evaluateFull(Double_t x) const;

	Int_t _nEvents;	Int_t _nEvents;

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

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

	Double_t g(Double_t x,Double_t sigma) const;	Double_t g(Double_t x,Double_t sigma) const;

	Bool_t _mirrorLeft, _mirrorRight;	Bool_t _mirrorLeft, _mirrorRight;
	Bool_t _asymLeft, _asymRight;	Bool_t _asymLeft, _asymRight;

	// cached info on variable	// cached info on variable
	Char_t _varName[128];	Char_t _varName[128];
	Double_t _lo, _hi, _binWidth;	Double_t _lo, _hi, _binWidth;
	Double_t _rho;	Double_t _rho;


	ClassDef(RooKeysPdf,1) // One-dimensional non-parametric kernel estimatio n p.d.f.	ClassDef(RooKeysPdf,2) // One-dimensional non-parametric kernel estimatio n p.d.f.
	};	};

	#endif	#endif

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

	RooLinTransBinning.h	RooLinTransBinning.h

	skipping to change at line 25	skipping to change at line 25
	************************************************************************ */	************************************************************************ */
	#ifndef ROO_LIN_TRANS_BINNING	#ifndef ROO_LIN_TRANS_BINNING
	#define ROO_LIN_TRANS_BINNING	#define ROO_LIN_TRANS_BINNING

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

	class RooLinTransBinning : public RooAbsBinning {	class RooLinTransBinning : public RooAbsBinning {
	public:	public:


	RooLinTransBinning(const char* name=0) : RooAbsBinning(name) {} ;	RooLinTransBinning(const char* name=0) : RooAbsBinning(name) {
		// coverity[UNINIT_CTOR]
		} ;
	RooLinTransBinning(const RooAbsBinning& input, Double_t slope=1.0, Double _t offset=0.0, const char* name=0) ;	RooLinTransBinning(const RooAbsBinning& input, Double_t slope=1.0, Double _t offset=0.0, const char* name=0) ;
	RooLinTransBinning(const RooLinTransBinning&, const char* name=0) ;	RooLinTransBinning(const RooLinTransBinning&, const char* name=0) ;
	virtual RooAbsBinning* clone(const char* name=0) const { return new RooLi nTransBinning(*this,name) ; }	virtual RooAbsBinning* clone(const char* name=0) const { return new RooLi nTransBinning(*this,name) ; }
	virtual ~RooLinTransBinning() ;	virtual ~RooLinTransBinning() ;

	virtual Int_t numBoundaries() const { return _input->numBoundaries() ; }	virtual Int_t numBoundaries() const { return _input->numBoundaries() ; }
	virtual Int_t binNumber(Double_t x) const { return _input->binNumber(invT rans(x)) ; }	virtual Int_t binNumber(Double_t x) const { return _input->binNumber(invT rans(x)) ; }
	virtual Double_t binCenter(Int_t bin) const { return trans(_input->binCen ter(binTrans(bin))) ; }	virtual Double_t binCenter(Int_t bin) const { return trans(_input->binCen ter(binTrans(bin))) ; }
	virtual Double_t binWidth(Int_t bin) const { return _slope*_input->binWid th(binTrans(bin)) ; }	virtual Double_t binWidth(Int_t bin) const { return _slope*_input->binWid th(binTrans(bin)) ; }
	virtual Double_t binLow(Int_t bin) const { if (_slope>0) return trans(_in put->binLow(binTrans(bin))) ; else return trans(_input->binHigh(binTrans(bi n))) ; }	virtual Double_t binLow(Int_t bin) const { if (_slope>0) return trans(_in put->binLow(binTrans(bin))) ; else return trans(_input->binHigh(binTrans(bi n))) ; }

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

	RooLinkedListElem.h	RooLinkedListElem.h

	skipping to change at line 20	skipping to change at line 20
	* 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_LINKED_LIST_ELEM	#ifndef ROO_LINKED_LIST_ELEM
	#define ROO_LINKED_LIST_ELEM	#define ROO_LINKED_LIST_ELEM

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

	#include "RooLinkedListElem.h"

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

	class RooLinkedListElem {	class RooLinkedListElem {
	public:	public:
	// Initial element ctor	// Initial element ctor
	RooLinkedListElem(TObject* arg) :	RooLinkedListElem(TObject* arg) :
	// Constructor with payload	// Constructor with payload

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

	RooLinkedListIter.h	RooLinkedListIter.h

	skipping to change at line 33	skipping to change at line 33

	#if ROOT_VERSION_CODE <= 332546	#if ROOT_VERSION_CODE <= 332546
	#ifndef nullptr	#ifndef nullptr
	#define nullptr 0	#define nullptr 0
	#endif	#endif
	#endif	#endif

	class RooLinkedListIter : public TIterator {	class RooLinkedListIter : public TIterator {
	public:	public:


	RooLinkedListIter() {} ;	RooLinkedListIter() {
		// coverity[UNINIT_CTOR]
		} ;

	RooLinkedListIter(const RooLinkedList* list, Bool_t forward) :	RooLinkedListIter(const RooLinkedList* list, Bool_t forward) :
	TIterator(), _forward(forward), _list(list)	TIterator(), _forward(forward), _list(list)
	{	{
	// Constructor from list with direction	// Constructor from list with direction
	_ptr = _list->_first ;	_ptr = _list->_first ;
	_cptr = _ptr;	_cptr = _ptr;
	}	}

	RooLinkedListIter(const RooLinkedListIter& other) :	RooLinkedListIter(const RooLinkedListIter& other) :

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

	RooListProxy.h	RooListProxy.h

	skipping to change at line 29	skipping to change at line 29
	#include "TObject.h"	#include "TObject.h"
	#include "Riosfwd.h"	#include "Riosfwd.h"
	#include "RooAbsProxy.h"	#include "RooAbsProxy.h"
	#include "RooAbsArg.h"	#include "RooAbsArg.h"
	#include "RooArgList.h"	#include "RooArgList.h"

	class RooListProxy : public RooArgList, public RooAbsProxy {	class RooListProxy : public RooArgList, public RooAbsProxy {
	public:	public:

	// Constructors, assignment etc.	// Constructors, assignment etc.

	RooListProxy() { _iter = createIterator() ; _owner=0 ; } ;	RooListProxy() : _defValueServer(kTRUE), _defShapeServer(kFALSE) { _iter = createIterator() ; _owner=0 ; } ;
	RooListProxy(const char* name, const char* desc, RooAbsArg* owner,	RooListProxy(const char* name, const char* desc, RooAbsArg* owner,
	Bool_t defValueServer=kTRUE, Bool_t defShapeServer=kFALSE) ;	Bool_t defValueServer=kTRUE, Bool_t defShapeServer=kFALSE) ;
	RooListProxy(const char* name, RooAbsArg* owner, const RooListProxy& othe r) ;	RooListProxy(const char* name, RooAbsArg* owner, const RooListProxy& othe r) ;
	virtual ~RooListProxy() ;	virtual ~RooListProxy() ;

	virtual const char* name() const { return GetName() ; }	virtual const char* name() const { return GetName() ; }

	// List content management (modified for server hooks)	// List content management (modified for server hooks)
	virtual Bool_t add(const RooAbsArg& var, Bool_t silent=kFALSE) ;	virtual Bool_t add(const RooAbsArg& var, Bool_t silent=kFALSE) ;
	virtual Bool_t add(const RooAbsCollection& list, Bool_t silent=kFALSE) { return RooAbsCollection::add(list,silent) ; }	virtual Bool_t add(const RooAbsCollection& list, Bool_t silent=kFALSE) { return RooAbsCollection::add(list,silent) ; }

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

	RooMCStudy.h	RooMCStudy.h

	skipping to change at line 36	skipping to change at line 36
	class RooAbsGenContext ;	class RooAbsGenContext ;
	class RooFitResult ;	class RooFitResult ;
	class RooPlot ;	class RooPlot ;
	class RooRealVar ;	class RooRealVar ;
	class RooAbsMCStudyModule ;	class RooAbsMCStudyModule ;

	class RooMCStudy : public TNamed {	class RooMCStudy : public TNamed {
	public:	public:

	RooMCStudy(const RooAbsPdf& model, const RooArgSet& observables,	RooMCStudy(const RooAbsPdf& model, const RooArgSet& observables,

	RooCmdArg arg1=RooCmdArg::none(), RooCmdArg arg2=RooCmdArg::non	const RooCmdArg& arg1=RooCmdArg::none(), const RooCmdArg& arg2=
	e(),	RooCmdArg::none(),
	RooCmdArg arg3=RooCmdArg::none(), RooCmdArg arg4=RooCmdArg::no	const RooCmdArg& arg3=RooCmdArg::none(), const RooCmdArg& arg4
	ne(), RooCmdArg arg5=RooCmdArg::none(),	=RooCmdArg::none(), const RooCmdArg& arg5=RooCmdArg::none(),
	RooCmdArg arg6=RooCmdArg::none(), RooCmdArg arg7=RooCmdArg::no	const RooCmdArg& arg6=RooCmdArg::none(), const RooCmdArg& arg7
	ne(), RooCmdArg arg8=RooCmdArg::none()) ;	=RooCmdArg::none(), const RooCmdArg& arg8=RooCmdArg::none()) ;

	RooMCStudy(const RooAbsPdf& genModel, const RooAbsPdf& fitModel,	RooMCStudy(const RooAbsPdf& genModel, const RooAbsPdf& fitModel,
	const RooArgSet& dependents, const char* genOptions="",	const RooArgSet& dependents, const char* genOptions="",
	const char* fitOptions="", const RooDataSet* genProtoData=0,	const char* fitOptions="", const RooDataSet* genProtoData=0,
	const RooArgSet& projDeps=RooArgSet()) ;	const RooArgSet& projDeps=RooArgSet()) ;
	virtual ~RooMCStudy() ;	virtual ~RooMCStudy() ;

	// Method to add study modules	// Method to add study modules
	void addModule(RooAbsMCStudyModule& module) ;	void addModule(RooAbsMCStudyModule& module) ;


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

	RooMomentMorph.h	RooMomentMorph.h

	skipping to change at line 16	skipping to change at line 16

	#ifndef ROOMOMENTMORPH	#ifndef ROOMOMENTMORPH
	#define ROOMOMENTMORPH	#define ROOMOMENTMORPH

	#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 "RooSetProxy.h"	#include "RooSetProxy.h"

		#include "RooListProxy.h"
	#include "RooArgList.h"	#include "RooArgList.h"

	#include "TMatrixD.h"	#include "TMatrixD.h"
	#include "TVectorD.h"	#include "TVectorD.h"

	#include <vector>	#include <vector>
	#include <string>	#include <string>
	class RooChangeTracker ;	class RooChangeTracker ;

	class RooMomentMorph : public RooAbsPdf {	class RooMomentMorph : public RooAbsPdf {

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

	RooObjCacheManager.h	RooObjCacheManager.h
	/************************************************************************ *	/************************************************************************ *
	* Project: RooFit *	* Project: RooFit *
	* Package: RooFitCore *	* Package: RooFitCore *

	* File: $Id: RooObjCacheManager.h 24280 2008-06-15 20:57:45Z wouter $	* File: $Id: RooObjCacheManager.h 37505 2010-12-10 13:46:32Z wouter $
	* Authors: *	* Authors: *
	* WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *	* WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *
	* DK, David Kirkby, UC Irvine, dkirkby@uci.edu *	* DK, David Kirkby, UC Irvine, dkirkby@uci.edu *
	* *	* *
	* 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) *

	skipping to change at line 51	skipping to change at line 51
	virtual void operModeHook() ;	virtual void operModeHook() ;
	virtual void optimizeCacheMode(const RooArgSet& /obs/, RooArgSet& /opt Set/, RooLinkedList& /processedNodes/) ;	virtual void optimizeCacheMode(const RooArgSet& /obs/, RooArgSet& /opt Set/, RooLinkedList& /processedNodes/) ;
	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&) ;

	protected:	protected:

	Bool_t _clearOnRedirect ;	Bool_t _clearOnRedirect ;

	Bool_t _optCacheModeSeen ;	Bool_t _optCacheModeSeen ; //!

	std::list<RooArgSet*> _optCacheObsList ; //! list of all optCacheObservab les owned	std::list<RooArgSet*> _optCacheObsList ; //! list of all optCacheObservab les owned
	RooArgSet* _optCacheObservables ; //! current optCacheObservables	RooArgSet* _optCacheObservables ; //! current optCacheObservables


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

	#endif	#endif

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

	RooPoisson.h	RooPoisson.h

	skipping to change at line 20	skipping to change at line 20
	#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"

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

	RooPoisson() {} ;	RooPoisson() { _noRounding = kFALSE ; } ;
	RooPoisson(const char name, const char title, RooAbsReal& _x, RooAbsRea	RooPoisson(const char name, const char title, RooAbsReal& _x, RooAbsRea
	l& _mean);	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() { }

	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);

	protected:	protected:

	RooRealProxy x ;	RooRealProxy x ;
	RooRealProxy mean ;	RooRealProxy mean ;

		Bool_t _noRounding ;

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

	private:	private:


	ClassDef(RooPoisson,1) // A Poisson PDF	ClassDef(RooPoisson,2) // A Poisson PDF
	};	};

	#endif	#endif

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

	RooProfileLL.h	RooProfileLL.h

	skipping to change at line 26	skipping to change at line 26
	#include "RooRealProxy.h"	#include "RooRealProxy.h"
	#include "RooSetProxy.h"	#include "RooSetProxy.h"
	#include <map>	#include <map>
	#include <string>	#include <string>

	class RooMinuit ;	class RooMinuit ;

	class RooProfileLL : public RooAbsReal {	class RooProfileLL : public RooAbsReal {
	public:	public:


		RooProfileLL() ;
	RooProfileLL(const char name, const char title, RooAbsReal& nll, const RooArgSet& observables);	RooProfileLL(const char name, const char title, RooAbsReal& nll, const RooArgSet& observables);
	RooProfileLL(const RooProfileLL& other, const char* name=0) ;	RooProfileLL(const RooProfileLL& other, const char* name=0) ;
	virtual TObject* clone(const char* newname) const { return new RooProfile LL(*this,newname); }	virtual TObject* clone(const char* newname) const { return new RooProfile LL(*this,newname); }
	virtual ~RooProfileLL() ;	virtual ~RooProfileLL() ;

	void setAlwaysStartFromMin(Bool_t flag) { _startFromMin = flag ; }	void setAlwaysStartFromMin(Bool_t flag) { _startFromMin = flag ; }
	Bool_t alwaysStartFromMin() const { return _startFromMin ; }	Bool_t alwaysStartFromMin() const { return _startFromMin ; }

	RooMinuit* minuit() { return _minuit ; }	RooMinuit* minuit() { return _minuit ; }
	RooAbsReal& nll() { return const_cast<RooAbsReal&>(_nll.arg()) ; }	RooAbsReal& nll() { return const_cast<RooAbsReal&>(_nll.arg()) ; }

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

	RooRealProxy.h	RooRealProxy.h

	skipping to change at line 53	skipping to change at line 53
	protected:	protected:

	RooAbsRealLValue* lvptr() const ;	RooAbsRealLValue* lvptr() const ;

	public:	public:

	// LValue operations	// LValue operations
	RooRealProxy& operator=(const Double_t& value) { lvptr()->setVal(value) ; return *this ; }	RooRealProxy& operator=(const Double_t& value) { lvptr()->setVal(value) ; return *this ; }
	Double_t min(const char* rname=0) const { return lvptr()->getMin(rname) ; }	Double_t min(const char* rname=0) const { return lvptr()->getMin(rname) ; }
	Double_t max(const char* rname=0) const { return lvptr()->getMax(rname) ; }	Double_t max(const char* rname=0) const { return lvptr()->getMax(rname) ; }

		Bool_t hasMin(const char* rname=0) const { return lvptr()->hasMin(rname)
		; }
		Bool_t hasMax(const char* rname=0) const { return lvptr()->hasMax(rname)
		; }

	ClassDef(RooRealProxy,1) // Proxy for a RooAbsReal object	ClassDef(RooRealProxy,1) // Proxy for a RooAbsReal object
	};	};

	#endif	#endif

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

	RooSetProxy.h	RooSetProxy.h

	skipping to change at line 34	skipping to change at line 34

	class RooSetProxy : public RooArgSet, public RooAbsProxy {	class RooSetProxy : public RooArgSet, public RooAbsProxy {
	public:	public:

	#ifdef USEMEMPOOL	#ifdef USEMEMPOOL
	void* operator new (size_t bytes);	void* operator new (size_t bytes);
	void operator delete (void *ptr);	void operator delete (void *ptr);
	#endif	#endif

	// Constructors, assignment etc.	// Constructors, assignment etc.

	RooSetProxy() { _iter = createIterator() ; _owner = 0 ; } ;	RooSetProxy() {
		// coverity[UNINIT_CTOR]
		_iter = createIterator() ; _owner = 0 ;
		} ;
	RooSetProxy(const char* name, const char* desc, RooAbsArg* owner,	RooSetProxy(const char* name, const char* desc, RooAbsArg* owner,
	Bool_t defValueServer=kTRUE, Bool_t defShapeServer=kFALSE) ;	Bool_t defValueServer=kTRUE, Bool_t defShapeServer=kFALSE) ;
	RooSetProxy(const char* name, RooAbsArg* owner, const RooSetProxy& other) ;	RooSetProxy(const char* name, RooAbsArg* owner, const RooSetProxy& other) ;
	virtual ~RooSetProxy() ;	virtual ~RooSetProxy() ;

	virtual const char* name() const { return GetName() ; }	virtual const char* name() const { return GetName() ; }

	// List content management (modified for server hooks)	// List content management (modified for server hooks)
	virtual Bool_t add(const RooAbsArg& var, Bool_t silent=kFALSE) ;	virtual Bool_t add(const RooAbsArg& var, Bool_t silent=kFALSE) ;
	virtual Bool_t add(const RooAbsCollection& list, Bool_t silent=kFALSE) { return RooAbsCollection::add(list,silent) ; }	virtual Bool_t add(const RooAbsCollection& list, Bool_t silent=kFALSE) { return RooAbsCollection::add(list,silent) ; }

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

	RooSimWSTool.h	RooSimWSTool.h
	/************************************************************************ *	/************************************************************************ *
	* Project: RooFit *	* Project: RooFit *
	* Package: RooFitCore *	* Package: RooFitCore *

	* File: $Id: RooSimWSTool.h 28259 2009-04-16 16:21:16Z wouter $	* File: $Id: RooSimWSTool.h 36209 2010-10-08 21:37:36Z wouter $
	* Authors: *	* Authors: *
	* WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *	* WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *
	* DK, David Kirkby, UC Irvine, dkirkby@uci.edu *	* DK, David Kirkby, UC Irvine, dkirkby@uci.edu *
	* *	* *
	* 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) *

	skipping to change at line 156	skipping to change at line 156
	friend class RooSimWSTool ;	friend class RooSimWSTool ;
	friend class RooSimWSTool::ObjBuildConfig ;	friend class RooSimWSTool::ObjBuildConfig ;
	std::list<const RooCatType*> _miStateList ;	std::list<const RooCatType*> _miStateList ;
	std::map<RooAbsArg*, std::pair<RooArgSet,std::string> > _paramSplitMap ; //<paramName,<list<splitCatSet>,remainderStateName>>	std::map<RooAbsArg*, std::pair<RooArgSet,std::string> > _paramSplitMap ; //<paramName,<list<splitCatSet>,remainderStateName>>
	ClassDef(ObjSplitRule,0) // Validated RooSimWSTool split rule	ClassDef(ObjSplitRule,0) // Validated RooSimWSTool split rule
	} ;	} ;

	class RooSimWSTool::ObjBuildConfig	class RooSimWSTool::ObjBuildConfig
	{	{
	public:	public:

	ObjBuildConfig() {} ;	ObjBuildConfig() : _masterCat(0) {} ;
	virtual ~ObjBuildConfig() {} ;	virtual ~ObjBuildConfig() {} ;
	void print() ;	void print() ;

	protected:	protected:
	friend class RooSimWSTool ;	friend class RooSimWSTool ;
	std::map<RooAbsPdf*,ObjSplitRule> _pdfmap ;	std::map<RooAbsPdf*,ObjSplitRule> _pdfmap ;
	std::map<RooAbsCategory,std::list<const RooCatType> > _restr ;	std::map<RooAbsCategory,std::list<const RooCatType> > _restr ;
	RooCategory* _masterCat ;	RooCategory* _masterCat ;
	RooArgSet _usedSplitCats ;	RooArgSet _usedSplitCats ;
	RooCmdArg _conflProtocol ;	RooCmdArg _conflProtocol ;

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

	RooSimultaneous.h	RooSimultaneous.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_SIMULTANEOUS	#ifndef ROO_SIMULTANEOUS
	#define ROO_SIMULTANEOUS	#define ROO_SIMULTANEOUS

	//#include "THashList.h"	//#include "THashList.h"
	#include "TList.h"	#include "TList.h"
	#include "RooAbsPdf.h"	#include "RooAbsPdf.h"
	#include "RooCategoryProxy.h"	#include "RooCategoryProxy.h"

		#include "RooRealProxy.h"
	#include "RooSetProxy.h"	#include "RooSetProxy.h"
	#include "RooAICRegistry.h"	#include "RooAICRegistry.h"
	#include "RooObjCacheManager.h"	#include "RooObjCacheManager.h"
	#include "RooAbsCacheElement.h"	#include "RooAbsCacheElement.h"
	#include "RooArgList.h"	#include "RooArgList.h"
	#include <map>	#include <map>
	#include <string>	#include <string>
	class RooAbsCategoryLValue ;	class RooAbsCategoryLValue ;
	class RooFitResult ;	class RooFitResult ;
	class RooPlot ;	class RooPlot ;

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

	RooStatsUtils.h	RooStatsUtils.h

	// @(#)root/roostats:$Id: RooStatsUtils.h 35810 2010-09-27 20:05:22Z moneta $	// @(#)root/roostats:$Id: RooStatsUtils.h 37161 2010-12-01 22:04:07Z moneta $
	// Author: Kyle Cranmer 28/07/2008	// Author: Kyle Cranmer 28/07/2008

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, 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 RooStats_RooStatsUtils	#ifndef RooStats_RooStatsUtils
	#define RooStats_RooStatsUtils	#define RooStats_RooStatsUtils

	#ifndef ROOT_TMath	#ifndef ROOT_TMath
	#include "TMath.h"	#include "TMath.h"
	#endif	#endif


	#ifndef ROOT_Math_DistFunc	#ifndef ROOT_Math_DistFuncMathCore
	#include"Math/DistFunc.h"	#include"Math/DistFuncMathCore.h"
	#endif	#endif

	#include "RooArgSet.h"	#include "RooArgSet.h"
	#include "RooRealVar.h"	#include "RooRealVar.h"
	#include "RooAbsCollection.h"	#include "RooAbsCollection.h"
	#include "TIterator.h"	#include "TIterator.h"

	#include <iostream>	#include <iostream>
	using namespace std ;	using namespace std ;


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

	SVEvent.h	SVEvent.h

	// @(#)root/tmva $Id: SVEvent.h 31458 2009-11-30 13:58:20Z stelzer $	// @(#)root/tmva $Id: SVEvent.h 37252 2010-12-04 09:57:53Z evt $
	// Author: Andrzej Zemla	// Author: Andrzej Zemla

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : SVEvent *	* Class : SVEvent *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Event class for Support Vector Machine *	* Event class for Support Vector Machine *

	skipping to change at line 47	skipping to change at line 47

	namespace TMVA	namespace TMVA
	{	{
	class Event;	class Event;

	class SVEvent {	class SVEvent {

	public:	public:

	SVEvent();	SVEvent();

	SVEvent( const Event*, const Float_t );	SVEvent( const Event*, Float_t );
	SVEvent( const std::vector<Float_t>*, Float_t alpha, const Int_t type	SVEvent( const std::vector<Float_t>*, Float_t alpha, Int_t typeFlag,
	Flag, const UInt_t ns );	UInt_t ns );
	SVEvent( const std::vector<Float_t>* svector, Float_t alpha, Float_t	SVEvent( const std::vector<Float_t>* svector, Float_t alpha, Float_t
	alpha_p,const Int_t typeFlag);	alpha_p, Int_t typeFlag);

	virtual ~SVEvent();	virtual ~SVEvent();

	void SetAlpha ( Float_t alpha ) { fAlpha = alpha; }	void SetAlpha ( Float_t alpha ) { fAlpha = alpha; }
	void SetAlpha_p ( Float_t alpha ) { fAlpha_p = alpha; }	void SetAlpha_p ( Float_t alpha ) { fAlpha_p = alpha; }
	void SetErrorCache ( Float_t err_cache ) { fErrorCache = err_cach e; }	void SetErrorCache ( Float_t err_cache ) { fErrorCache = err_cach e; }
	void SetIsShrinked ( Int_t isshrinked ) { fIsShrinked = isshrink ed; }	void SetIsShrinked ( Int_t isshrinked ) { fIsShrinked = isshrink ed; }
	void SetLine ( Float_t* line ) { fLine = line; }	void SetLine ( Float_t* line ) { fLine = line; }
	void SetIdx ( Int_t idx ) { fIdx = idx; }	void SetIdx ( Int_t idx ) { fIdx = idx; }
	void SetNs ( UInt_t ns ) { fNs = ns; }	void SetNs ( UInt_t ns ) { fNs = ns; }

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

	SamplingDistPlot.h	SamplingDistPlot.h

	// @(#)root/roostats:$Id: SamplingDistPlot.h 34109 2010-06-24 15:00:16Z mon eta $	// @(#)root/roostats:$Id: SamplingDistPlot.h 37333 2010-12-06 14:26:57Z mon eta $
	// Authors: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Authors: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, 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 ROOSTATS_SamplingDistPlot	#ifndef ROOSTATS_SamplingDistPlot

	skipping to change at line 35	skipping to change at line 35
	#ifndef ROO_PLOT	#ifndef ROO_PLOT
	#include "RooPlot.h"	#include "RooPlot.h"
	#endif	#endif

	namespace RooStats {	namespace RooStats {

	class SamplingDistPlot : public TNamed, public RooPrintable {	class SamplingDistPlot : public TNamed, public RooPrintable {

	public:	public:
	// Constructors for SamplingDistribution	// Constructors for SamplingDistribution

	SamplingDistPlot(const Int_t nbins = 100);	SamplingDistPlot(Int_t nbins = 100);
	SamplingDistPlot(const char* name, const char* title, Int_t nbins, Doub	// SamplingDistPlot(const char* name, const char* title, Int_t nbins, Do
	le_t xmin, Double_t xmax);	uble_t xmin, Double_t xmax);

	// Destructor of SamplingDistribution	// Destructor of SamplingDistribution

	virtual ~SamplingDistPlot();	virtual ~SamplingDistPlot() {}

	// adds the sampling distribution and returns the scale factor	// adds the sampling distribution and returns the scale factor

	Double_t AddSamplingDistribution(const SamplingDistribution samplingDi st, Option_t drawOptions=0);	Double_t AddSamplingDistribution(const SamplingDistribution samplingDi st, Option_t drawOptions="NORMALIZE HIST");
	// Like AddSamplingDistribution, but also sets a shaded area in the	// Like AddSamplingDistribution, but also sets a shaded area in the
	// minShaded and maxShaded boundaries.	// minShaded and maxShaded boundaries.

	Double_t AddSamplingDistributionShaded(const SamplingDistribution samp lingDist, Double_t minShaded, Double_t maxShaded, Option_t drawOptions);	Double_t AddSamplingDistributionShaded(const SamplingDistribution samp lingDist, Double_t minShaded, Double_t maxShaded, Option_t drawOptions="NO RMALIZE HIST");

	// add a line	// add a line
	void AddLine(Double_t x1, Double_t y1, Double_t x2, Double_t y2, const char* title = NULL);	void AddLine(Double_t x1, Double_t y1, Double_t x2, Double_t y2, const char* title = NULL);


	void Draw(const Option_t *options=0);	void Draw(Option_t *options=0);

	// Applies a predefined style if fApplyStyle is kTRUE (default).	// Applies a predefined style if fApplyStyle is kTRUE (default).
	void ApplyDefaultStyle(void);	void ApplyDefaultStyle(void);


	void SetLineColor(const Color_t color, const SamplingDistribution *samp	void SetLineColor(Color_t color, const SamplingDistribution *samplDist
	lDist = 0);	= 0);
	void SetLineWidth(const Width_t lwidth, const SamplingDistribution *sam	void SetLineWidth(Width_t lwidth, const SamplingDistribution *samplDist
	plDist = 0);	= 0);
	void SetLineStyle(const Style_t style, const SamplingDistribution *samp	void SetLineStyle(Style_t style, const SamplingDistribution *samplDist
	lDist = 0);	= 0);

	void SetMarkerColor(const Color_t color, const SamplingDistribution *sa	void SetMarkerColor(Color_t color, const SamplingDistribution *samplDis
	mplDist = 0);	t = 0);
	void SetMarkerStyle(const Style_t style, const SamplingDistribution *sa	void SetMarkerStyle(Style_t style, const SamplingDistribution *samplDis
	mplDist = 0);	t = 0);
	void SetMarkerSize(const Size_t size, const SamplingDistribution *sampl	void SetMarkerSize(Size_t size, const SamplingDistribution *samplDist =
	Dist = 0);	0);


	void RebinDistribution(const Int_t rebinFactor, const SamplingDistribut ion *samplDist = 0);	void RebinDistribution(Int_t rebinFactor, const SamplingDistribution *s amplDist = 0);

	void SetAxisTitle(char *varName) { fVarName = TString(varName); }	void SetAxisTitle(char *varName) { fVarName = TString(varName); }

	// If you do not want SamplingDistPlot to interfere with your style set tings, call this	// If you do not want SamplingDistPlot to interfere with your style set tings, call this
	// function with "false" before Draw().	// function with "false" before Draw().

	void SetApplyStyle(const Bool_t s) { fApplyStyle = s; }	void SetApplyStyle(Bool_t s) { fApplyStyle = s; }

	// Returns the TH1F associated with the give SamplingDistribution.	// Returns the TH1F associated with the give SamplingDistribution.
	// Intended use: Access to member functions of TH1F like GetMean(),	// Intended use: Access to member functions of TH1F like GetMean(),
	// GetRMS() etc.	// GetRMS() etc.
	TH1F* GetTH1F(const SamplingDistribution *samplDist);	TH1F* GetTH1F(const SamplingDistribution *samplDist);

	// changes plot to log scale on x axis	// changes plot to log scale on x axis

	void SetLogXaxis(const Bool_t lx) { fLogXaxis = lx; }	void SetLogXaxis(Bool_t lx) { fLogXaxis = lx; }
	// changes plot to log scale on y axis	// changes plot to log scale on y axis

	void SetLogYaxis(const Bool_t ly) { fLogYaxis = ly; }	void SetLogYaxis(Bool_t ly) { fLogYaxis = ly; }

	// write to Root file	// write to Root file
	void DumpToFile(const char* RootFileName, Option_t option="", const ch ar ftitle="", Int_t compress=1);	void DumpToFile(const char* RootFileName, Option_t option="", const ch ar ftitle="", Int_t compress=1);

	private:	private:
	std::vector<Double_t> fSamplingDistr;	std::vector<Double_t> fSamplingDistr;
	std::vector<Double_t> fSampleWeights;	std::vector<Double_t> fSampleWeights;

	Bool_t fIsWeighted;	Bool_t fIsWeighted;


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

	SamplingDistribution.h	SamplingDistribution.h

	// @(#)root/roostats:$Id: SamplingDistribution.h 34109 2010-06-24 15:00:16Z moneta $	// @(#)root/roostats:$Id: SamplingDistribution.h 36604 2010-11-11 16:58:54Z moneta $

	/*************************************************************************	/*************************************************************************
	* Project: RooStats *	* Project: RooStats *
	* Package: RooFit/RooStats *	* Package: RooFit/RooStats *
	* Authors: *	* Authors: *
	* Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke *	* Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke *
	*************************************************************************	*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *

	skipping to change at line 24	skipping to change at line 24
	*************************************************************************/	*************************************************************************/

	#ifndef ROOSTATS_SamplingDistribution	#ifndef ROOSTATS_SamplingDistribution
	#define ROOSTATS_SamplingDistribution	#define ROOSTATS_SamplingDistribution

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

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

		#include "RooDataSet.h"

	#include <vector>	#include <vector>

	namespace RooStats {	namespace RooStats {

	class SamplingDistribution : public TNamed {	class SamplingDistribution : public TNamed {

	public:	public:

	// Constructor for SamplingDistribution	// Constructor for SamplingDistribution

	SamplingDistribution(const char name,const char title, std::vector<Do uble_t>& samplingDist, const TString varName = "");	SamplingDistribution(const char name,const char title, std::vector<Do uble_t>& samplingDist, const char * varName = 0);
	SamplingDistribution(const char name,const char title,	SamplingDistribution(const char name,const char title,

	std::vector<Double_t>& samplingDist, std::vector<Do uble_t>& sampleWeights, const TString varName = "");	std::vector<Double_t>& samplingDist, std::vector<Do uble_t>& sampleWeights, const char * varName = 0);


	SamplingDistribution(const char name,const char title, const TString	SamplingDistribution(const char name,const char title, const char * v
	varName = "");	arName = 0);

		SamplingDistribution(const char name,const char title, RooDataSet& da
		taSet, const char * varName = 0);

	// Default constructor for SamplingDistribution	// Default constructor for SamplingDistribution
	SamplingDistribution();	SamplingDistribution();

	// Destructor of SamplingDistribution	// Destructor of SamplingDistribution
	virtual ~SamplingDistribution();	virtual ~SamplingDistribution();

	// get the inverse of the Cumulative distribution function	// get the inverse of the Cumulative distribution function
	Double_t InverseCDF(Double_t pvalue);	Double_t InverseCDF(Double_t pvalue);


	skipping to change at line 72	skipping to change at line 75
	// Get test statistics values	// Get test statistics values
	std::vector<Double_t> GetSamplingDistribution() const {return fSampling Dist;}	std::vector<Double_t> GetSamplingDistribution() const {return fSampling Dist;}
	// Get the sampling weights	// Get the sampling weights
	std::vector<Double_t> GetSampleWeights() const {return fSampleWeights;}	std::vector<Double_t> GetSampleWeights() const {return fSampleWeights;}

	const TString GetVarName() const {return fVarName;}	const TString GetVarName() const {return fVarName;}

	// numerical integral in these limits	// numerical integral in these limits
	Double_t Integral(Double_t low, Double_t high, Bool_t normalize = kTRUE ) const;	Double_t Integral(Double_t low, Double_t high, Bool_t normalize = kTRUE ) const;


		// calculate CDF as a special case of Integral(...) with lower limit eq
		ual to -inf
		Double_t CDF(Double_t x) const;

	private:	private:
	std::vector<Double_t> fSamplingDist; // vector of points for the sampli ng distribution	std::vector<Double_t> fSamplingDist; // vector of points for the sampli ng distribution
	std::vector<Double_t> fSampleWeights; // vector of weights for the samp les	std::vector<Double_t> fSampleWeights; // vector of weights for the samp les
	// store a RooRealVar that this distribution corresponds to?	// store a RooRealVar that this distribution corresponds to?

	TString fVarName;	TString fVarName;

	protected:	protected:

	ClassDef(SamplingDistribution,1) // Class containing the results of th e HybridCalculator	ClassDef(SamplingDistribution,1) // Class containing the results of th e HybridCalculator

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

	ScopeBase.h	ScopeBase.h

	// @(#)root/reflex:$Id: ScopeBase.h 32228 2010-02-05 16:13:09Z axel $	// @(#)root/reflex:$Id: ScopeBase.h 36289 2010-10-11 09:54:28Z axel $
	// Author: Stefan Roiser 2004	// Author: Stefan Roiser 2004

	// Copyright CERN, CH-1211 Geneva 23, 2004-2010, All rights reserved.	// Copyright CERN, CH-1211 Geneva 23, 2004-2010, All rights reserved.
	//	//
	// Permission to use, copy, modify, and distribute this software for any	// Permission to use, copy, modify, and distribute this software for any
	// purpose is hereby granted without fee, provided that this copyright and	// purpose is hereby granted without fee, provided that this copyright and
	// permissions notice appear in all copies and derivatives.	// permissions notice appear in all copies and derivatives.
	//	//
	// This software is provided "as is" without express or implied warranty.	// This software is provided "as is" without express or implied warranty.

	#ifndef Reflex_ScopeBase	#ifndef Reflex_ScopeBase
	#define Reflex_ScopeBase	#define Reflex_ScopeBase

	// Include files	// Include files
	#include "Reflex/Kernel.h"	#include "Reflex/Kernel.h"


		#ifndef Reflex_Scope
	#include "Reflex/Scope.h"	#include "Reflex/Scope.h"

		#endif
	#include "Reflex/internal/OwnedPropertyList.h"	#include "Reflex/internal/OwnedPropertyList.h"
	#include "Reflex/internal/BuilderContainer.h"	#include "Reflex/internal/BuilderContainer.h"
	#include <vector>	#include <vector>

	#ifdef _WIN32	#ifdef _WIN32
	# pragma warning( push )	# pragma warning( push )
	# pragma warning( disable : 4251 )	# pragma warning( disable : 4251 )
	#endif	#endif

	namespace Reflex {	namespace Reflex {

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

	SdivSqrtSplusB.h	SdivSqrtSplusB.h

	// @(#)root/tmva $Id: SdivSqrtSplusB.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: SdivSqrtSplusB.h 37399 2010-12-08 15:22:07Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : SdivSqrtSplusB *	* Class : SdivSqrtSplusB *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: Implementation of the SdivSqrtSplusB as separation criterio n *	* Description: Implementation of the SdivSqrtSplusB as separation criterio n *
	* S/sqrt(S + B) *	* S/sqrt(S + B) *

	skipping to change at line 51	skipping to change at line 51
	#include "TMVA/SeparationBase.h"	#include "TMVA/SeparationBase.h"
	#endif	#endif

	namespace TMVA {	namespace TMVA {

	class SdivSqrtSplusB : public SeparationBase {	class SdivSqrtSplusB : public SeparationBase {

	public:	public:

	//constructor for the "statistical significance" index	//constructor for the "statistical significance" index

	SdivSqrtSplusB() { fName = "StatSig"; }	SdivSqrtSplusB(): SeparationBase() { fName = "StatSig"; }

	// copy constructor	// copy constructor
	SdivSqrtSplusB( const SdivSqrtSplusB& g): SeparationBase(g) {}	SdivSqrtSplusB( const SdivSqrtSplusB& g): SeparationBase(g) {}

	//destructor	//destructor
	virtual ~SdivSqrtSplusB() {}	virtual ~SdivSqrtSplusB() {}

	// return the Index (S/sqrt(S+B))	// return the Index (S/sqrt(S+B))
	virtual Double_t GetSeparationIndex( const Double_t &s, const Double _t &b );	virtual Double_t GetSeparationIndex( const Double_t &s, const Double _t &b );


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

	SeparationBase.h	SeparationBase.h

	// @(#)root/tmva $Id: SeparationBase.h 35727 2010-09-24 21:41:20Z stelzer $	// @(#)root/tmva $Id: SeparationBase.h 37399 2010-12-08 15:22:07Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : SeparationBase *	* Class : SeparationBase *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: An interface to different separation critiera useded in var ious *	* Description: An interface to different separation critiera useded in var ious *
	* training algorithms, as there are: *	* training algorithms, as there are: *

	skipping to change at line 80	skipping to change at line 80
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_Rtypes	#ifndef ROOT_Rtypes
	#include "Rtypes.h"	#include "Rtypes.h"
	#endif	#endif

	#ifndef ROOT_TString	#ifndef ROOT_TString
	#include "TString.h"	#include "TString.h"
	#endif	#endif


		#ifndef ROOT_TMath
		#include "TMath.h"
		#endif

		#include <limits>

	namespace TMVA {	namespace TMVA {

	class SeparationBase {	class SeparationBase {

	public:	public:

	// default constructor	// default constructor
	SeparationBase();	SeparationBase();


	// copy constructor	//copy constructor
	SeparationBase( const SeparationBase& s );	SeparationBase( const SeparationBase& s );

	// destructor	// destructor
	virtual ~SeparationBase(){}	virtual ~SeparationBase(){}

	// Return the gain in separation of the original sample is splitted i n two sub-samples	// Return the gain in separation of the original sample is splitted i n two sub-samples
	// (N * Index_parent) - (N_left * Index_left) - (N_right * Index_righ t)	// (N * Index_parent) - (N_left * Index_left) - (N_right * Index_righ t)
	Double_t GetSeparationGain( const Double_t& nSelS, const Double_t& nS elB,	Double_t GetSeparationGain( const Double_t& nSelS, const Double_t& nS elB,
	const Double_t& nTotS, const Double_t& nT otB );	const Double_t& nTotS, const Double_t& nT otB );


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

	SimpleLikelihoodRatioTestStat.h	SimpleLikelihoodRatioTestStat.h

	// @(#)root/roostats:$Id: SimpleLikelihoodRatioTestStat.h 34109 2010-06-24 15:00:16Z moneta $	// @(#)root/roostats:$Id: SimpleLikelihoodRatioTestStat.h 36602 2010-11-11 16:52:13Z moneta $
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, 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 ROOSTATS_SimpleLikelihoodRatioTestStat	#ifndef ROOSTATS_SimpleLikelihoodRatioTestStat
	#define ROOSTATS_SimpleLikelihoodRatioTestStat	#define ROOSTATS_SimpleLikelihoodRatioTestStat

	//_________________________________________________	//_________________________________________________
	/*	/*

	BEGIN_HTML	BEGIN_HTML
	<p>	<p>
	SimpleLikelihoodRatioTestStat: TestStatistic that returns -log(L[null] / L[	SimpleLikelihoodRatioTestStat: TestStatistic that returns -log(L[null] / L
	alt]) where	[alt]) where
	L is the likelihood.	L is the likelihood.
	</p>	</p>
	END_HTML	END_HTML
	*/	*/
	//	//

	#ifndef ROOT_Rtypes	#ifndef ROOT_Rtypes
	#include "Rtypes.h"	#include "Rtypes.h"
	#endif	#endif

	#ifndef ROO_NLL_VAR	#ifndef ROO_NLL_VAR
	#include "RooNLLVar.h"	#include "RooNLLVar.h"
	#endif	#endif

	#include "RooStats/TestStatistic.h"	#include "RooStats/TestStatistic.h"

	namespace RooStats {	namespace RooStats {


	class SimpleLikelihoodRatioTestStat: public TestStatistic {	class SimpleLikelihoodRatioTestStat : public TestStatistic {

	public:	public:


	//__________________________________	//__________________________________
	SimpleLikelihoodRatioTestStat(RooAbsPdf& nullPdf, RooAbsPdf& altPdf) :	SimpleLikelihoodRatioTestStat() :
	fNullPdf(nullPdf), fAltPdf(altPdf)	fNullPdf(NULL), fAltPdf(NULL)
	{
	// b/c null and alternate parameters are not set, it will take
	// values from PDF. Can override
	fFirstEval=true;
	fNullParameters = (RooArgSet*)fNullPdf.getVariables()->snapshot();
	fAltParameters = (RooArgSet*)fAltPdf.getVariables()->snapshot();
	}

	//__________________________________
	SimpleLikelihoodRatioTestStat(RooAbsPdf& nullPdf, RooAbsPdf& altPdf, cons
	t RooArgSet& nullParameters, const RooArgSet& altParameters) :
	fNullPdf(nullPdf), fAltPdf(altPdf)
	{	{

	// constructor, explicitly set parameters.	// Constructor for proof. Do not use.
	// note to developers, constructor with two const RooArgSet*	fFirstEval = true;
	// causes problems if the usage is	fNullParameters = NULL;
	// null.GetSnapshot(), alt.GetSnapshot()	fAltParameters = NULL;
	// because both are pointers to the same set, and you will	}
	// get duplicate values.
		//__________________________________
	fFirstEval=true;	SimpleLikelihoodRatioTestStat(
	fNullParameters = (RooArgSet*)nullParameters.snapshot();	RooAbsPdf& nullPdf,
	fAltParameters = (RooArgSet*)altParameters.snapshot();	RooAbsPdf& altPdf
		) :
		fFirstEval(true)
		{
		// Takes null and alternate parameters from PDF. Can be overridden
		.

		RooFit::MsgLevel msglevel = RooMsgService::instance().globalKillBe
		low();
		RooMsgService::instance().setGlobalKillBelow(RooFit::ERROR);
		w.import(nullPdf, RooFit::RecycleConflictNodes());
		w.import(altPdf, RooFit::RecycleConflictNodes());
		RooMsgService::instance().setGlobalKillBelow(msglevel);

		fNullPdf = w.pdf(nullPdf.GetName());
		fAltPdf = w.pdf(altPdf.GetName());


		fNullParameters = (RooArgSet*) fNullPdf->getVariables()->snapshot(
		);
		fAltParameters = (RooArgSet*) fAltPdf->getVariables()->snapshot();
	}	}

		//__________________________________
		SimpleLikelihoodRatioTestStat(
		RooAbsPdf& nullPdf,
		RooAbsPdf& altPdf,
		const RooArgSet& nullParameters,
		const RooArgSet& altParameters
		) :
		fFirstEval(true)
		{
		// Takes null and alternate parameters from values in nullParamete
		rs
		// and altParameters. Can be overridden.

		RooFit::MsgLevel msglevel = RooMsgService::instance().globalKillBe
		low();
		RooMsgService::instance().setGlobalKillBelow(RooFit::ERROR);
		w.import(nullPdf, RooFit::RecycleConflictNodes());
		w.import(altPdf, RooFit::RecycleConflictNodes());
		RooMsgService::instance().setGlobalKillBelow(msglevel);

		fNullPdf = w.pdf(nullPdf.GetName());
		fAltPdf = w.pdf(altPdf.GetName());


	//_________________________________________	fNullParameters = (RooArgSet*) nullParameters.snapshot();
	void SetNullParameters(const RooArgSet& nullParameters){	fAltParameters = (RooArgSet*) altParameters.snapshot();
	delete fNullParameters;	}
	fFirstEval=true;
	// if(fNullParameters) delete fNullParameters;	//______________________________
	fNullParameters = (RooArgSet*)nullParameters.snapshot();	virtual ~SimpleLikelihoodRatioTestStat() {
	}	if (fNullParameters) delete fNullParameters;
		if (fAltParameters) delete fAltParameters;
	//_________________________________________	}
	void SetAltParameters(const RooArgSet& altParameters){
	delete fAltParameters;	//_________________________________________
	fFirstEval=true;	void SetNullParameters(const RooArgSet& nullParameters) {
	// if(fAltParameters) delete fAltParameters;	if (fNullParameters) delete fNullParameters;
	fAltParameters = (RooArgSet*)altParameters.snapshot();	fFirstEval = true;
	}	// if(fNullParameters) delete fNullParameters;
	//______________________________	fNullParameters = (RooArgSet*) nullParameters.snapshot();
	virtual ~SimpleLikelihoodRatioTestStat() {	}
	delete fNullParameters;
	delete fAltParameters;	//_________________________________________
	}	void SetAltParameters(const RooArgSet& altParameters) {
		if (fAltParameters) delete fAltParameters;
	//______________________________	fFirstEval = true;
	bool ParamsAreEqual(){	// if(fAltParameters) delete fAltParameters;
	// this should be possible with RooAbsCollection	fAltParameters = (RooArgSet*) altParameters.snapshot();
	if(!fNullParameters->equals(*fAltParameters))	}
	return false;
		//______________________________
	RooAbsReal* null;	bool ParamsAreEqual() {
	RooAbsReal* alt;	// this should be possible with RooAbsCollection
		if (!fNullParameters->equals(*fAltParameters)) return false;
	TIterator* nullIt = fNullParameters->createIterator();
	TIterator* altIt = fAltParameters->createIterator();	RooAbsReal* null;
	bool ret =true;	RooAbsReal* alt;
	while((null = (RooAbsReal*) nullIt->Next()) &&
	(alt = (RooAbsReal*) altIt->Next()) ){	TIterator* nullIt = fNullParameters->createIterator();
	if(null->getVal() != alt->getVal() ) ret = false;	TIterator* altIt = fAltParameters->createIterator();
	}	bool ret = true;
	delete nullIt;	while ((null = (RooAbsReal*) nullIt->Next()) && (alt = (RooAbsReal
	delete altIt;	*) altIt->Next())) {
	return ret;	if (null->getVal() != alt->getVal()) ret = false;
	}	}
		delete nullIt;
	//______________________________	delete altIt;
	virtual Double_t Evaluate(RooAbsData& data, RooArgSet& /nullPOI/) {	return ret;
		}
	if( fFirstEval && ParamsAreEqual()){
	oocoutW(fNullParameters,InputArguments) << "Same RooArgSet used fo	//______________________________
	r null and alternate, so you must explicitly SetNullParameters and SetAlter	virtual Double_t Evaluate(RooAbsData& data, RooArgSet& nullPOI) {
	nateParameters or the likelihood ratio will always be 1." << endl;
	}	if (fFirstEval && ParamsAreEqual()) {
	fFirstEval=false;	oocoutW(fNullParameters,InputArguments)
		<< "Same RooArgSet used for null and alternate, so you must
		explicitly SetNullParameters and SetAlternateParameters or the likelihood r
		atio will always be 1."
		<< endl;
		}
		fFirstEval = false;

	RooFit::MsgLevel msglevel = RooMsgService::instance().globalKillBe low();	RooFit::MsgLevel msglevel = RooMsgService::instance().globalKillBe low();
	RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL);	RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL);

	RooAbsReal *nll;	RooAbsReal *nll;

	nll = fNullPdf.createNLL(data, RooFit::CloneData(kFALSE));	nll = fNullPdf->createNLL(data, RooFit::CloneData(kFALSE));
	// make sure we set the variables attached to this nll	// make sure we set the variables attached to this nll
	RooArgSet* attachedSet = nll->getVariables();	RooArgSet* attachedSet = nll->getVariables();
	attachedSet = fNullParameters;	attachedSet = fNullParameters;
		*attachedSet = nullPOI;
	double nullNLL = nll->getVal();	double nullNLL = nll->getVal();
	delete nll;	delete nll;

	delete attachedSet;	delete attachedSet;


	nll = fAltPdf.createNLL(data, RooFit::CloneData(kFALSE));	nll = fAltPdf->createNLL(data, RooFit::CloneData(kFALSE));
	// make sure we set the variables attached to this nll	// make sure we set the variables attached to this nll
	attachedSet = nll->getVariables();	attachedSet = nll->getVariables();
	attachedSet = fAltParameters;	attachedSet = fAltParameters;
	double altNLL = nll->getVal();	double altNLL = nll->getVal();
	delete nll;	delete nll;

	delete attachedSet;	delete attachedSet;

	RooMsgService::instance().setGlobalKillBelow(msglevel);	RooMsgService::instance().setGlobalKillBelow(msglevel);
	return nullNLL - altNLL;	return nullNLL - altNLL;
	}	}


	virtual const TString GetVarName() const { return "log(L(#mu_{1}) / L	virtual const TString GetVarName() const {
	(#mu_{0}))"; }	return "log(L(#mu_{1}) / L(#mu_{0}))";
		}

	private:	private:

	RooAbsPdf& fNullPdf;	RooWorkspace w;
	RooAbsPdf& fAltPdf;
		RooAbsPdf* fNullPdf;
		RooAbsPdf* fAltPdf;
	RooArgSet* fNullParameters;	RooArgSet* fNullParameters;
	RooArgSet* fAltParameters;	RooArgSet* fAltParameters;
	bool fFirstEval;	bool fFirstEval;

	protected:	protected:
	ClassDef(SimpleLikelihoodRatioTestStat,1)	ClassDef(SimpleLikelihoodRatioTestStat,1)
	};	};

	}	}


End of changes. 14 change blocks.
	100 lines changed or deleted	138 lines changed or added

	SpecFuncMathMore.h	SpecFuncMathMore.h

	// @(#)root/mathmore:$Id: SpecFuncMathMore.h 34054 2010-06-22 12:27:30Z mon eta $	// @(#)root/mathmore:$Id: SpecFuncMathMore.h 37160 2010-12-01 21:52:04Z mon eta $
	// Authors: L. Moneta, A. Zsenei 08/2005	// Authors: L. Moneta, A. Zsenei 08/2005

	// Authors: Andras Zsenei & Lorenzo Moneta 06/2005	// Authors: Andras Zsenei & Lorenzo Moneta 06/2005

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *
	* *	* *
	* This library is free software; you can redistribute it and/or *	* This library is free software; you can redistribute it and/or *
	* modify it under the terms of the GNU General Public License *	* modify it under the terms of the GNU General Public License *

	skipping to change at line 699	skipping to change at line 699
	The implementation used is that of	The implementation used is that of
	<A HREF="http://www.gnu.org/software/gsl/manual/html_node/Zeros-of-Deriva tives-of-Airy-Functions.html">GSL</A>.	<A HREF="http://www.gnu.org/software/gsl/manual/html_node/Zeros-of-Deriva tives-of-Airy-Functions.html">GSL</A>.

	@ingroup SpecFunc	@ingroup SpecFunc

	*/	*/
	// s-th zero of the derivative of the Airy function Bi	// s-th zero of the derivative of the Airy function Bi

	double airy_zero_Bi_deriv(unsigned int s);	double airy_zero_Bi_deriv(unsigned int s);


		/**

		Calculates the Wigner 3j coupling coefficients

		For detailed description see
		<A HREF="http://mathworld.wolfram.com/Wigner3j-Symbol.html.html">
		Mathworld</A>.
		The implementation used is that of
		<A HREF="http://www.gnu.org/software/gsl/manual/html_node/3_002dj-Symbols
		.html#g_t3_002dj-Symbols">GSL</A>.

		@ingroup SpecFunc

		*/

		double wigner_3j(int ja, int jb, int jc, int ma, int mb, int mc);

		/**

		Calculates the Wigner 6j coupling coefficients

		For detailed description see
		<A HREF="http://mathworld.wolfram.com/Wigner6j-Symbol.html">
		Mathworld</A>.
		The implementation used is that of
		<A HREF="http://www.gnu.org/software/gsl/manual/html_node/6_002dj-Symbols
		.html#g_t6_002dj-Symbols">GSL</A>.

		@ingroup SpecFunc

		*/

		double wigner_6j(int ja, int jb, int jc, int jd, int je, int jf);

		/**

		Calculates the Wigner 9j coupling coefficients

		For detailed description see
		<A HREF="http://mathworld.wolfram.com/Wigner9j-Symbol.html">
		Mathworld</A>.
		The implementation used is that of
		<A HREF="http://www.gnu.org/software/gsl/manual/html_node/9_002dj-Symbols
		.html#g_t9_002dj-Symbols">GSL</A>.

		@ingroup SpecFunc

		*/

		double wigner_9j(int ja, int jb, int jc, int jd, int je, int jf, int jg,
		int jh, int ji);

	} // namespace Math	} // namespace Math
	} // namespace ROOT	} // namespace ROOT

	#endif //ROOT_Math_SpecFuncMathMore	#endif //ROOT_Math_SpecFuncMathMore

	#endif // if defined (__CINT__) && !defined(__MAKECINT__)	#endif // if defined (__CINT__) && !defined(__MAKECINT__)

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

	TBranchElement.h	TBranchElement.h

	// @(#)root/tree:$Id: TBranchElement.h 34969 2010-08-24 19:01:19Z pcanal $	// @(#)root/tree:$Id: TBranchElement.h 36061 2010-10-04 16:05:51Z pcanal $
	// Author: Rene Brun 14/01/2001	// Author: Rene Brun 14/01/2001

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, 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 35	skipping to change at line 35

	#ifndef ROOT_TClassRef	#ifndef ROOT_TClassRef
	#include "TClassRef.h"	#include "TClassRef.h"
	#endif	#endif

	#include <vector>	#include <vector>

	class TFolder;	class TFolder;
	class TStreamerInfo;	class TStreamerInfo;
	class TVirtualCollectionProxy;	class TVirtualCollectionProxy;

		class TVirtualCollectionIterators;
		class TVirtualCollectionPtrIterators;
	class TVirtualArray;	class TVirtualArray;


		namespace TStreamerInfoActions { class TActionSequence; }

	class TBranchElement : public TBranch {	class TBranchElement : public TBranch {

	// Friends	// Friends
	friend class TTreeCloner;	friend class TTreeCloner;

	// Types	// Types
	protected:	protected:
	enum {	enum {
	kBranchFolder = BIT(14),	kBranchFolder = BIT(14),
	kDeleteObject = BIT(16), // We are the owner of fObject.	kDeleteObject = BIT(16), // We are the owner of fObject.

	skipping to change at line 82	skipping to change at line 86
	char fObject; //! Pointer to object at fAddr ess	char fObject; //! Pointer to object at fAddr ess
	TVirtualArray *fOnfileObject; //! Place holder for the onfile representation of data members.	TVirtualArray *fOnfileObject; //! Place holder for the onfile representation of data members.
	Bool_t fInit; //! Initialization flag for bra nch assignment	Bool_t fInit; //! Initialization flag for bra nch assignment
	Bool_t fInitOffsets; //! Initialization flag to not endlessly recalculate offsets	Bool_t fInitOffsets; //! Initialization flag to not endlessly recalculate offsets
	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
	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.
		TVirtualCollectionIterators *fIterators; //! holds the ite
		rators when the branch is of fType==4.
		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.
	protected:	protected:

	skipping to change at line 112	skipping to change at line 119
	void ValidateAddress() const;	void ValidateAddress() const;

	void Init(TTree tree, TBranch parent, const char* name, TStreamerInfo* sinfo, Int_t id, char* pointer, Int_t basketsize = 32000, Int_t splitlevel = 0, Int_t btype = 0);	void Init(TTree tree, TBranch parent, const char* name, TStreamerInfo* sinfo, Int_t id, char* pointer, Int_t basketsize = 32000, Int_t splitlevel = 0, Int_t btype = 0);
	void Init(TTree tree, TBranch parent, const char* name, TClonesArray* clones, Int_t basketsize = 32000, Int_t splitlevel = 0, Int_t compress = -1 );	void Init(TTree tree, TBranch parent, const char* name, TClonesArray* clones, Int_t basketsize = 32000, Int_t splitlevel = 0, Int_t compress = -1 );
	void Init(TTree tree, TBranch parent, const char* name, TVirtualCollec tionProxy* cont, Int_t basketsize = 32000, Int_t splitlevel = 0, Int_t comp ress = -1);	void Init(TTree tree, TBranch parent, const char* name, TVirtualCollec tionProxy* cont, Int_t basketsize = 32000, Int_t splitlevel = 0, Int_t comp ress = -1);

	void ReadLeavesImpl(TBuffer& b);	void ReadLeavesImpl(TBuffer& b);
	void ReadLeavesMakeClass(TBuffer& b);	void ReadLeavesMakeClass(TBuffer& b);
	void ReadLeavesCollection(TBuffer& b);	void ReadLeavesCollection(TBuffer& b);
	void ReadLeavesCollectionSplitPtrMember(TBuffer& b);	void ReadLeavesCollectionSplitPtrMember(TBuffer& b);

		void ReadLeavesCollectionSplitVectorPtrMember(TBuffer& b);
	void ReadLeavesCollectionMember(TBuffer& b);	void ReadLeavesCollectionMember(TBuffer& b);
	void ReadLeavesClones(TBuffer& b);	void ReadLeavesClones(TBuffer& b);
	void ReadLeavesClonesMember(TBuffer& b);	void ReadLeavesClonesMember(TBuffer& b);
	void ReadLeavesCustomStreamer(TBuffer& b);	void ReadLeavesCustomStreamer(TBuffer& b);
	void ReadLeavesMember(TBuffer& b);	void ReadLeavesMember(TBuffer& b);
	void ReadLeavesMemberBranchCount(TBuffer& b);	void ReadLeavesMemberBranchCount(TBuffer& b);
	void ReadLeavesMemberCounter(TBuffer& b);	void ReadLeavesMemberCounter(TBuffer& b);
	void SetReadLeavesPtr();	void SetReadLeavesPtr();

		void SetReadActionSequence();

	// Public Interface.	// Public Interface.
	public:	public:
	TBranchElement();	TBranchElement();
	TBranchElement(TTree tree, const char name, TStreamerInfo* sinfo, Int_ t id, char* pointer, Int_t basketsize = 32000, Int_t splitlevel = 0, Int_t btype = 0);	TBranchElement(TTree tree, const char name, TStreamerInfo* sinfo, Int_ t id, char* pointer, Int_t basketsize = 32000, Int_t splitlevel = 0, Int_t btype = 0);
	TBranchElement(TTree tree, const char name, TClonesArray* clones, Int_ t basketsize = 32000, Int_t splitlevel = 0, Int_t compress = -1);	TBranchElement(TTree tree, const char name, TClonesArray* clones, Int_ t basketsize = 32000, Int_t splitlevel = 0, Int_t compress = -1);
	TBranchElement(TTree tree, const char name, TVirtualCollectionProxy* c ont, Int_t basketsize = 32000, Int_t splitlevel = 0, Int_t compress = -1);	TBranchElement(TTree tree, const char name, TVirtualCollectionProxy* c ont, Int_t basketsize = 32000, Int_t splitlevel = 0, Int_t compress = -1);
	TBranchElement(TBranch parent, const char name, TStreamerInfo* sinfo, Int_t id, char* pointer, Int_t basketsize = 32000, Int_t splitlevel = 0, In t_t btype = 0);	TBranchElement(TBranch parent, const char name, TStreamerInfo* sinfo, Int_t id, char* pointer, Int_t basketsize = 32000, Int_t splitlevel = 0, In t_t btype = 0);
	TBranchElement(TBranch parent, const char name, TClonesArray* clones, Int_t basketsize = 32000, Int_t splitlevel = 0, Int_t compress = -1);	TBranchElement(TBranch parent, const char name, TClonesArray* clones, Int_t basketsize = 32000, Int_t splitlevel = 0, Int_t compress = -1);
	TBranchElement(TBranch parent, const char name, TVirtualCollectionProx y* cont, Int_t basketsize = 32000, Int_t splitlevel = 0, Int_t compress = - 1);	TBranchElement(TBranch parent, const char name, TVirtualCollectionProx y* cont, Int_t basketsize = 32000, Int_t splitlevel = 0, Int_t compress = - 1);

	skipping to change at line 177	skipping to change at line 186
	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 ResetAddress();	virtual void ResetAddress();
	virtual void ResetDeleteObject();	virtual void ResetDeleteObject();
	virtual void SetAddress(void* addobj);	virtual void SetAddress(void* addobj);
	virtual Bool_t SetMakeClass(Bool_t decomposeObj = kTRUE);	virtual Bool_t SetMakeClass(Bool_t decomposeObj = kTRUE);
	virtual void SetObject(void *objadd);	virtual void SetObject(void *objadd);
	virtual void SetBasketSize(Int_t buffsize);	virtual void SetBasketSize(Int_t buffsize);
	virtual void SetBranchFolder() { SetBit(kBranchFolder); }	virtual void SetBranchFolder() { SetBit(kBranchFolder); }
	virtual void SetClassName(const char* name) { fClassName = n ame; }	virtual void SetClassName(const char* name) { fClassName = n ame; }

		virtual void SetOffset(Int_t offset);
	inline void SetParentClass(TClass* clparent);	inline void SetParentClass(TClass* clparent);
	virtual void SetParentName(const char* name) { fParentName = name; }	virtual void SetParentName(const char* name) { fParentName = name; }
	virtual void SetTargetClassName(const char *name);	virtual void SetTargetClassName(const char *name);
	virtual void SetupAddresses();	virtual void SetupAddresses();
	virtual void SetType(Int_t btype) { fType = btype; }	virtual void SetType(Int_t btype) { fType = btype; }
	virtual void UpdateFile();	virtual void UpdateFile();

	ClassDef(TBranchElement,9) // Branch in case of an object	ClassDef(TBranchElement,9) // Branch in case of an object
	};	};


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

	TBranchObject.h	TBranchObject.h

	// @(#)root/tree:$Id: TBranchObject.h 23230 2008-04-15 15:33:32Z pcanal $	// @(#)root/tree:$Id: TBranchObject.h 37168 2010-12-02 02:34:55Z pcanal $
	// Author: Rene Brun 11/02/96	// Author: Rene Brun 11/02/96

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, 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 53	skipping to change at line 53
	virtual Int_t Fill();	virtual Int_t Fill();
	virtual const char* GetClassName() const { return fClassName.Data(); };	virtual const char* GetClassName() const { return fClassName.Data(); };
	virtual const char* GetObjClassName() { return fClassName.Data(); };	virtual const char* GetObjClassName() { return fClassName.Data(); };
	virtual Int_t GetEntry(Long64_t entry=0, Int_t getall = 0);	virtual Int_t GetEntry(Long64_t entry=0, Int_t getall = 0);
	Bool_t IsFolder() const;	Bool_t IsFolder() const;
	virtual void Print(Option_t *option="") const;	virtual void Print(Option_t *option="") const;
	virtual void Reset(Option_t *option="");	virtual void Reset(Option_t *option="");
	virtual void SetAddress(void *addobj);	virtual void SetAddress(void *addobj);
	virtual void SetAutoDelete(Bool_t autodel=kTRUE);	virtual void SetAutoDelete(Bool_t autodel=kTRUE);
	virtual void SetBasketSize(Int_t buffsize);	virtual void SetBasketSize(Int_t buffsize);

		virtual void SetupAddresses();
	virtual void UpdateAddress();	virtual void UpdateAddress();

	ClassDef(TBranchObject,1); //Branch in case of an object	ClassDef(TBranchObject,1); //Branch in case of an object
	};	};

	#endif	#endif

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

	TBranchProxy.h	TBranchProxy.h

	// @(#)root/treeplayer:$Id: TBranchProxy.h 35344 2010-09-16 21:34:21Z pcana l $	// @(#)root/treeplayer:$Id: TBranchProxy.h 36449 2010-10-28 20:52:17Z pcana l $
	// Author: Philippe Canal 01/06/2004	// Author: Philippe Canal 01/06/2004

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers and al. *	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers and al. *
	* 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 261	skipping to change at line 261
	return (void*)(location);	return (void*)(location);
	} else {	} else {
	return location;	return location;
	}	}

	}	}

	virtual void *GetStlStart(UInt_t i=0) {	virtual void *GetStlStart(UInt_t i=0) {
	// return the address of the start of the object being proxied. As sumes	// return the address of the start of the object being proxied. As sumes
	// that Setup() has been called. Assumes the object containing th is data	// that Setup() has been called. Assumes the object containing th is data

	// member is held in TClonesArray.	// member is held in STL Collection.

	char *location=0;	char *location=0;

	if (fCollection) {	if (fCollection) {

	if (fCollection->Size()<i) return 0;	if (fCollection->Size()<i) return 0;

	location = (char*)fCollection->At(i);	location = (char*)fCollection->At(i);

	// return location;	// return location;

	skipping to change at line 301	skipping to change at line 301
	if (location) location += fOffset;	if (location) location += fOffset;
	else return 0;	else return 0;

	if (IsaPointer()) {	if (IsaPointer()) {
	return (void*)(location);	return (void*)(location);
	} else {	} else {
	return location;	return location;
	}	}

	}	}


		Int_t GetOffset() { return fOffset; }
	};	};

	//______________________________________________________________________ ______________________	//______________________________________________________________________ ______________________
	// Concrete Implementation of the branch proxy around the data members w hich are array of char	// Concrete Implementation of the branch proxy around the data members w hich are array of char
	class TArrayCharProxy : public TBranchProxy {	class TArrayCharProxy : public TBranchProxy {
	public:	public:
	void Print() {	void Print() {
	TBranchProxy::Print();	TBranchProxy::Print();
	cout << "fWhere " << fWhere << endl;	cout << "fWhere " << fWhere << endl;
	if (fWhere) cout << "value? " << (unsigned char)GetStart() << en dl;	if (fWhere) cout << "value? " << (unsigned char)GetStart() << en dl;

	skipping to change at line 421	skipping to change at line 423
	TStlProxy(TBranchProxyDirector director, const char top, const char *name) :	TStlProxy(TBranchProxyDirector director, const char top, const char *name) :
	TBranchProxy(director,top,name) {};	TBranchProxy(director,top,name) {};
	TStlProxy(TBranchProxyDirector director, const char top, const char name, const char data) :	TStlProxy(TBranchProxyDirector director, const char top, const char name, const char data) :
	TBranchProxy(director,top,name,data) {};	TBranchProxy(director,top,name,data) {};
	TStlProxy(TBranchProxyDirector director, TBranchProxy parent, const char name, const char top = 0, const char* mid = 0) :	TStlProxy(TBranchProxyDirector director, TBranchProxy parent, const char name, const char top = 0, const char* mid = 0) :
	TBranchProxy(director,parent, name, top, mid) {};	TBranchProxy(director,parent, name, top, mid) {};
	~TStlProxy() {};	~TStlProxy() {};

	const TVirtualCollectionProxy* GetPtr() {	const TVirtualCollectionProxy* GetPtr() {
	if (!Read()) return 0;	if (!Read()) return 0;

	return GetCollection();;	return GetCollection();
	}	}

	Int_t GetEntries() {	Int_t GetEntries() {
	if (!ReadEntries()) return 0;	if (!ReadEntries()) return 0;
	return GetPtr()->Size();	return GetPtr()->Size();
	}	}

	const TVirtualCollectionProxy* operator->() { return GetPtr(); }	const TVirtualCollectionProxy* operator->() { return GetPtr(); }

	};	};

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

	TBranchProxyClassDescriptor.h	TBranchProxyClassDescriptor.h

	// @(#)root/treeplayer:$Id: TBranchProxyClassDescriptor.h 21704 2008-01-14 22:52:10Z pcanal $	// @(#)root/treeplayer:$Id: TBranchProxyClassDescriptor.h 36449 2010-10-28 20:52:17Z pcanal $
	// Author: Philippe Canal 06/06/2004	// Author: Philippe Canal 06/06/2004

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers and al. *	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers and al. *
	* 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 36	skipping to change at line 36

	class TBranchProxyDescriptor;	class TBranchProxyDescriptor;

	class TBranchProxyClassDescriptor : public TNamed {	class TBranchProxyClassDescriptor : public TNamed {

	public:	public:
	enum ELocation { kOut=0, kClones, kSTL, kInsideClones, kInsideSTL }; // for IsClones	enum ELocation { kOut=0, kClones, kSTL, kInsideClones, kInsideSTL }; // for IsClones
	private:	private:
	TList fListOfSubProxies;	TList fListOfSubProxies;
	TList fListOfBaseProxies;	TList fListOfBaseProxies;

	ELocation fIsClones; // 1 for the general case, 2 when this a split clases inside a TClonesArray, 3 when this is a split classes insid e an STL container.	ELocation fIsClones; // 0 for the general case, 1 when this a split clases inside a TClonesArray, 2 when this is a split classes insid e an STL container.
	TString fContainerName; // Name of the container if any	TString fContainerName; // Name of the container if any
	Bool_t fIsLeafList; // true if the branch was constructed from a leaf list.	Bool_t fIsLeafList; // true if the branch was constructed from a leaf list.
	UInt_t fSplitLevel;	UInt_t fSplitLevel;

	TString fRawSymbol;	TString fRawSymbol;
	TString fBranchName;	TString fBranchName;
	TString fSubBranchPrefix;	TString fSubBranchPrefix;
	TVirtualStreamerInfo *fInfo; // TVirtualStreamerInfo describing t his class	TVirtualStreamerInfo *fInfo; // TVirtualStreamerInfo describing t his class

	UInt_t fMaxDatamemberType;	UInt_t fMaxDatamemberType;

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

	TBranchProxyTemplate.h	TBranchProxyTemplate.h

	// @(#)root/treeplayer:$Id: TBranchProxyTemplate.h 21708 2008-01-15 08:04:1 5Z pcanal $	// @(#)root/treeplayer:$Id: TBranchProxyTemplate.h 36449 2010-10-28 20:52:1 7Z pcanal $
	// Author: Philippe Canal 01/06/2004	// Author: Philippe Canal 01/06/2004

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers and al. *	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers and al. *
	* 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 44	skipping to change at line 44
	TObjProxy() : obj() {};	TObjProxy() : obj() {};
	TObjProxy(TBranchProxyDirector director, const char name) : obj(dir ector,name) {};	TObjProxy(TBranchProxyDirector director, const char name) : obj(dir ector,name) {};
	TObjProxy(TBranchProxyDirector director, const char top, const char *name) :	TObjProxy(TBranchProxyDirector director, const char top, const char *name) :
	obj(director,top,name) {};	obj(director,top,name) {};
	TObjProxy(TBranchProxyDirector director, const char top, const char name, const char data) :	TObjProxy(TBranchProxyDirector director, const char top, const char name, const char data) :
	obj(director,top,name,data) {};	obj(director,top,name,data) {};
	TObjProxy(TBranchProxyDirector director, TBranchProxy parent, const char name, const char top = 0, const char* mid = 0) :	TObjProxy(TBranchProxyDirector director, TBranchProxy parent, const char name, const char top = 0, const char* mid = 0) :
	obj(director,parent, name, top, mid) {};	obj(director,parent, name, top, mid) {};
	~TObjProxy() {};	~TObjProxy() {};


		Int_t GetOffset() { return obj.GetOffset(); }

	void Print() {	void Print() {
	obj.Print();	obj.Print();
	cout << "fWhere " << obj.GetWhere() << endl;	cout << "fWhere " << obj.GetWhere() << endl;
	if (obj.GetWhere()) cout << "address? " << (T*)obj.GetWhere() << e ndl;	if (obj.GetWhere()) cout << "address? " << (T*)obj.GetWhere() << e ndl;
	}	}

	T* GetPtr() {	T* GetPtr() {
	//static T default_val;	//static T default_val;
	if (!obj.Read()) return 0; // &default_val;	if (!obj.Read()) return 0; // &default_val;
	T temp = (T)obj.GetStart();	T temp = (T)obj.GetStart();

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

	TBranchRef.h	TBranchRef.h

	// @(#)root/tree:$Id: TBranchRef.h 34969 2010-08-24 19:01:19Z pcanal $	// @(#)root/tree:$Id: TBranchRef.h 37275 2010-12-04 21:32:11Z pcanal $
	// Author: Rene Brun 19/08/2004	// Author: Rene Brun 19/08/2004

	/*************************************************************************	/*************************************************************************
	* 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 49	skipping to change at line 49
	TBranchRef();	TBranchRef();
	TBranchRef(TTree *tree);	TBranchRef(TTree *tree);
	virtual ~TBranchRef();	virtual ~TBranchRef();
	virtual void Clear(Option_t *option="");	virtual void Clear(Option_t *option="");
	virtual Int_t Fill();	virtual Int_t Fill();
	virtual void FillLeaves(TBuffer &b);	virtual void FillLeaves(TBuffer &b);
	TRefTable *GetRefTable() const {return fRefTable;}	TRefTable *GetRefTable() const {return fRefTable;}
	virtual Bool_t Notify();	virtual Bool_t Notify();
	virtual void Print(Option_t *option="") const;	virtual void Print(Option_t *option="") const;
	virtual void Reset(Option_t *option="");	virtual void Reset(Option_t *option="");

	virtual Int_t SetParent(const TObject* obj, const Int_t branchID);	virtual Int_t SetParent(const TObject* obj, Int_t branchID);
	virtual void SetReadEntry(Long64_t entry) {fReadEntry = entry;}	virtual void SetReadEntry(Long64_t entry) {fReadEntry = entry;}

	ClassDef(TBranchRef,1); //to support referenced objects on other branch es	ClassDef(TBranchRef,1); //to support referenced objects on other branch es
	};	};

	#endif	#endif

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

	TChi2FitData.h	TChi2FitData.h

	// @(#)root/minuit2:$Id: TChi2FitData.h 20880 2007-11-19 11:23:41Z rdm $	// @(#)root/minuit2:$Id: TChi2FitData.h 36076 2010-10-05 09:13:12Z moneta $
	// Author: L. Moneta 10/2005	// Author: L. Moneta 10/2005

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2005 ROOT Foundation, CERN/PH-SFT *	* Copyright (c) 2005 ROOT Foundation, CERN/PH-SFT *
	* *	* *
	**********************************************************************/	**********************************************************************/

	#ifndef ROOT_TChi2FitData_H_	#ifndef ROOT_TChi2FitData_H_
	#define ROOT_TChi2FitData_H_	#define ROOT_TChi2FitData_H_

	skipping to change at line 41	skipping to change at line 41
	class TChi2FitData {	class TChi2FitData {

	public:	public:

	typedef std::vector<double> CoordData;	typedef std::vector<double> CoordData;

	/**	/**
	construct the Fit data object	construct the Fit data object
	*/	*/


	TChi2FitData() : fSize(0) {}	TChi2FitData() : fSize(0), fSkipEmptyBins(false), fIntegral(false) {}

	TChi2FitData(const TVirtualFitter & fitter, bool skipEmptyBins = true);	TChi2FitData(const TVirtualFitter & fitter, bool skipEmptyBins = true);

	virtual ~TChi2FitData() {}	virtual ~TChi2FitData() {}

	unsigned int Size() const { return fSize; }	unsigned int Size() const { return fSize; }

	const CoordData & Coords(unsigned int i) const { return fCoordinates[i]; }	const CoordData & Coords(unsigned int i) const { return fCoordinates[i]; }

	double Value(unsigned int i) const { return fValues[i]; }	double Value(unsigned int i) const { return fValues[i]; }

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

	TClassRef.h	TClassRef.h

	// @(#)root/meta:$Id: TClassRef.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/meta:$Id: TClassRef.h 36061 2010-10-04 16:05:51Z pcanal $
	// Author: Philippe Canal 15/03/2005	// Author: Philippe Canal 15/03/2005

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, 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 43	skipping to change at line 43
	class TClassRef {	class TClassRef {

	private:	private:
	std::string fClassName; //Name of referenced class	std::string fClassName; //Name of referenced class
	TClass *fClassPtr; //! Ptr to the TClass object	TClass *fClassPtr; //! Ptr to the TClass object
	TClassRef *fPrevious; //! link to the previous refs	TClassRef *fPrevious; //! link to the previous refs
	TClassRef *fNext; //! link to the next refs	TClassRef *fNext; //! link to the next refs

	friend class TClass;	friend class TClass;


		void Assign(const TClassRef &);
		void Assign(TClass *);
	TClass *InternalGetClass() const;	TClass *InternalGetClass() const;
	void ListReset();	void ListReset();
	public:	public:
	TClassRef() : fClassName(), fClassPtr(0), fPrevious(0), fNext(0) {}	TClassRef() : fClassName(), fClassPtr(0), fPrevious(0), fNext(0) {}
	TClassRef(TClass *cl);	TClassRef(TClass *cl);
	TClassRef(const char *classname);	TClassRef(const char *classname);
	TClassRef(const TClassRef&);	TClassRef(const TClassRef&);

	TClassRef &operator=(const TClassRef&);	inline TClassRef &operator=(const TClassRef &rhs) {
	TClassRef &operator=(TClass*);	// Inline implementation of operator= to speed the no-op case.
		if (this != &rhs && fClassPtr != rhs.fClassPtr) {
		this->Assign(rhs);
		}
		return *this;
		}
		inline TClassRef &operator=(TClass *rhs) {
		// Inline implementation of operator= to speed the no-op case.
		if (this->fClassPtr != rhs) {
		this->Assign(rhs);
		}
		return *this;
		}

	~TClassRef() { if (fClassPtr) fClassPtr->RemoveRef(this); };	~TClassRef() { if (fClassPtr) fClassPtr->RemoveRef(this); };

	void SetName(const char* new_name) {	void SetName(const char* new_name) {
	if ( fClassPtr && fClassName != new_name ) Reset();	if ( fClassPtr && fClassName != new_name ) Reset();
	fClassName = new_name;	fClassName = new_name;
	}	}
	const char *GetClassName() { return fClassName.c_str(); }	const char *GetClassName() { return fClassName.c_str(); }
	TClass *GetClass() const { return fClassPtr ? fClassPtr : InternalGetCl ass(); }	TClass *GetClass() const { return fClassPtr ? fClassPtr : InternalGetCl ass(); }
	void Reset() { if (fClassPtr) fClassPtr->RemoveRef(this); fClassPtr = 0; }	void Reset() { if (fClassPtr) fClassPtr->RemoveRef(this); fClassPtr = 0; }

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

	TClassStreamer.h	TClassStreamer.h

	// @(#)root/base:$Id: TClassStreamer.h 25450 2008-09-18 21:13:42Z pcanal $	// @(#)root/base:$Id: TClassStreamer.h 36096 2010-10-05 21:27:26Z pcanal $
	// Author: Victor Perev and Philippe Canal 08/05/02	// Author: Victor Perev and Philippe Canal 08/05/02

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2003, Rene Brun, Fons Rademakers and al. *	* Copyright (C) 1995-2003, Rene Brun, Fons Rademakers and al. *
	* 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 38	skipping to change at line 38
	protected:	protected:
	TClassStreamer() : fStreamer(0) {};	TClassStreamer() : fStreamer(0) {};

	public:	public:
	TClassStreamer(ClassStreamerFunc_t pointer) : fStreamer(pointer), fOnFil eClass() {};	TClassStreamer(ClassStreamerFunc_t pointer) : fStreamer(pointer), fOnFil eClass() {};
	TClassStreamer(const TClassStreamer &rhs) : fStreamer(rhs.fStreamer), fO nFileClass() {};	TClassStreamer(const TClassStreamer &rhs) : fStreamer(rhs.fStreamer), fO nFileClass() {};

	virtual void SetOnFileClass( const TClass* cl ) { fOnFileClass = const_c ast<TClass*>(cl); }	virtual void SetOnFileClass( const TClass* cl ) { fOnFileClass = const_c ast<TClass*>(cl); }
	virtual const TClass* GetOnFileClass() const { return fOnFileClass; }	virtual const TClass* GetOnFileClass() const { return fOnFileClass; }


	virtual TClassStreamer *Generate() {	virtual TClassStreamer *Generate() const {
	// Virtual copy constructor.	// Virtual copy constructor.
	return new TClassStreamer(*this);	return new TClassStreamer(*this);
	}	}

	virtual ~TClassStreamer(){};	virtual ~TClassStreamer(){};
	virtual void operator()(TBuffer &b, void *objp)	virtual void operator()(TBuffer &b, void *objp)
	{	{
	// The address passed to operator() will be the address of the start of the	// The address passed to operator() will be the address of the start of the
	// object.	// object.

	(*fStreamer)(b,objp);	(*fStreamer)(b,objp);
	}	}

		virtual void Stream(TBuffer &b, void objp, const TClass onfileClass)
		{
		// The address passed to operator() will be the address of the start
		of the
		// object. Overload this routine, if your derived class can optimiz
		e
		// the handling of the onfileClass (rather than storing and restoring
		from the
		// fOnFileClass member.

		// Note we can not name this routine 'operator()' has it would be sli
		ghtly
		// backward incompatible and lead to the following warning/error from
		the
		// compiler in the derived class overloading the other operator():
		// include/TClassStreamer.h:51: error: ‘virtual void TClassStreamer::o
		perator()(TBuffer&, void, const TClass)’ was hidden
		// include/TCollectionProxyFactory.h:180: error: by ‘virtual void TC
		ollectionClassStreamer::operator()(TBuffer&, void*)’
		// cc1plus: warnings being treated as errors

		SetOnFileClass(onfileClass);
		(*this)(b,objp);
		}

	private:	private:
	ClassStreamerFunc_t fStreamer;	ClassStreamerFunc_t fStreamer;
	protected:	protected:
	TClassRef fOnFileClass;	TClassRef fOnFileClass;
	};	};

	#endif	#endif

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

	TCollectionProxyFactory.h	TCollectionProxyFactory.h

	// @(#)root/io:$Id: TCollectionProxyFactory.h 30749 2009-10-15 16:33:04Z br un $	// @(#)root/io:$Id: TCollectionProxyFactory.h 36061 2010-10-04 16:05:51Z pc anal $
	// Author: Markus Frank 28/10/04	// Author: Markus Frank 28/10/04

	/*************************************************************************	/*************************************************************************
	* 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. *
	*************************************************************************/	*************************************************************************/
	#ifndef ROOT_TCollectionProxyFactory	#ifndef ROOT_TCollectionProxyFactory

	skipping to change at line 31	skipping to change at line 31
	#include <typeinfo>	#include <typeinfo>
	#include <vector>	#include <vector>

	#ifndef ROOT_TCollectionProxyInfo	#ifndef ROOT_TCollectionProxyInfo
	#include "TCollectionProxyInfo.h"	#include "TCollectionProxyInfo.h"
	#endif	#endif

	#ifndef ROOT_TClassStreamer	#ifndef ROOT_TClassStreamer
	#include "TClassStreamer.h"	#include "TClassStreamer.h"
	#endif	#endif


	#ifndef ROOT_TMemberStreamer	#ifndef ROOT_TMemberStreamer
	#include "TMemberStreamer.h"	#include "TMemberStreamer.h"
	#endif	#endif


		#ifndef ROOT_TGenCollectionProxy
		#include "TGenCollectionProxy.h"
		#endif

	// Forward declarations	// Forward declarations
	class TBuffer;	class TBuffer;
	class TGenCollectionProxy;	class TGenCollectionProxy;
	class TGenCollectionStreamer;	class TGenCollectionStreamer;
	class TVirtualCollectionProxy;	class TVirtualCollectionProxy;
	class TEmulatedCollectionProxy;	class TEmulatedCollectionProxy;

	#if defined(_WIN32)	#if defined(_WIN32)
	#if _MSC_VER<1300	#if _MSC_VER<1300
	#define TYPENAME	#define TYPENAME

	skipping to change at line 152	skipping to change at line 157
	public:	public:
	/// Initializing constructor	/// Initializing constructor
	TCollectionStreamer();	TCollectionStreamer();
	/// Copy constructor	/// Copy constructor
	TCollectionStreamer(const TCollectionStreamer& c);	TCollectionStreamer(const TCollectionStreamer& c);
	/// Standard destructor	/// Standard destructor
	virtual ~TCollectionStreamer();	virtual ~TCollectionStreamer();
	/// Attach worker proxy	/// Attach worker proxy
	void AdoptStreamer(TGenCollectionProxy* streamer);	void AdoptStreamer(TGenCollectionProxy* streamer);
	/// Streamer for I/O handling	/// Streamer for I/O handling

	void Streamer(TBuffer &refBuffer, void pObject, int siz, TClass onFile Class );	void Streamer(TBuffer &refBuffer, void obj, int siz, TClass onFileClas s );
	};	};

	/** @class TEmulatedClassStreamer TCollectionProxy.h cont/TCollectionProxy. h	/** @class TEmulatedClassStreamer TCollectionProxy.h cont/TCollectionProxy. h
	*	*
	* TEmulatedClassStreamer	* TEmulatedClassStreamer
	*	*
	* Class streamer object to implement TClassStreamr functionality	* Class streamer object to implement TClassStreamr functionality
	* for I/O emulation.	* for I/O emulation.
	*	*
	* @author M.Frank	* @author M.Frank

	skipping to change at line 175	skipping to change at line 180
	class TCollectionClassStreamer : public TClassStreamer, public TCollectionS treamer {	class TCollectionClassStreamer : public TClassStreamer, public TCollectionS treamer {
	public:	public:
	/// Initializing constructor	/// Initializing constructor
	TCollectionClassStreamer() : TClassStreamer(0) { }	TCollectionClassStreamer() : TClassStreamer(0) { }
	/// Copy constructor	/// Copy constructor
	TCollectionClassStreamer(const TCollectionClassStreamer& c)	TCollectionClassStreamer(const TCollectionClassStreamer& c)
	: TClassStreamer(c), TCollectionStreamer(c) { }	: TClassStreamer(c), TCollectionStreamer(c) { }
	/// Standard destructor	/// Standard destructor
	virtual ~TCollectionClassStreamer() { }	virtual ~TCollectionClassStreamer() { }
	/// Streamer for I/O handling	/// Streamer for I/O handling

	virtual void operator()(TBuffer &buff, void *pObj ) { Streamer(buff,pObj	virtual void operator()(TBuffer &buff, void *obj ) { Streamer(buff,obj,0
	,0,fOnFileClass); }	,fOnFileClass); }

		virtual void Stream(TBuffer &b, void obj, const TClass onfileClass)
		{
		if (b.IsReading()) {
		TGenCollectionProxy *proxy = TCollectionStreamer::fStreamer;
		if (onfileClass==0 \|\| onfileClass == proxy->GetCollectionClass())
		{
		proxy->ReadBuffer(b,obj);
		} else {
		proxy->ReadBuffer(b,obj,onfileClass);
		}
		} else {
		// fStreamer->WriteBuffer(b,objp,onfileClass);
		Streamer(b,obj,0,(TClass*)onfileClass);
		}
		}

	/// Virtual copy constructor.	/// Virtual copy constructor.

	virtual TClassStreamer *Generate() {	virtual TClassStreamer *Generate() const {
	return new TCollectionClassStreamer(*this);	return new TCollectionClassStreamer(*this);
	}	}

	TGenCollectionProxy *GetXYZ() { return TCollectionStreamer::fStreamer; }	TGenCollectionProxy *GetXYZ() { return TCollectionStreamer::fStreamer; }

	};	};

	/** @class TCollectionMemberStreamer TCollectionProxyFactory.h cont/TCollec tionProxyFactory.h	/** @class TCollectionMemberStreamer TCollectionProxyFactory.h cont/TCollec tionProxyFactory.h
	*	*
	* TCollectionMemberStreamer	* TCollectionMemberStreamer

	skipping to change at line 206	skipping to change at line 226
	class TCollectionMemberStreamer : public TMemberStreamer, public TCollectio nStreamer {	class TCollectionMemberStreamer : public TMemberStreamer, public TCollectio nStreamer {
	public:	public:
	/// Initializing constructor	/// Initializing constructor
	TCollectionMemberStreamer() : TMemberStreamer(0) { }	TCollectionMemberStreamer() : TMemberStreamer(0) { }
	/// Copy constructor	/// Copy constructor
	TCollectionMemberStreamer(const TCollectionMemberStreamer& c)	TCollectionMemberStreamer(const TCollectionMemberStreamer& c)
	: TMemberStreamer(c), TCollectionStreamer(c) { }	: TMemberStreamer(c), TCollectionStreamer(c) { }
	/// Standard destructor	/// Standard destructor
	virtual ~TCollectionMemberStreamer() { }	virtual ~TCollectionMemberStreamer() { }
	/// Streamer for I/O handling	/// Streamer for I/O handling

	virtual void operator()(TBuffer &buff,void *pObj,Int_t siz=0)	virtual void operator()(TBuffer &buff,void *obj,Int_t siz=0)
	{ Streamer(buff, pObj, siz, 0); /* FIXME */ }	{ Streamer(buff, obj, siz, 0); /* FIXME */ }
	};	};

	#endif	#endif

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

	TCollectionProxyInfo.h	TCollectionProxyInfo.h

	// @(#)root/cont:$Id: TCollectionProxyInfo.h 32611 2010-03-15 15:26:56Z rdm $	// @(#)root/cont:$Id: TCollectionProxyInfo.h 36061 2010-10-04 16:05:51Z pca nal $
	// Author: Markus Frank 28/10/04. Philippe Canal 02/01/2007	// Author: Markus Frank 28/10/04. Philippe Canal 02/01/2007

	/*************************************************************************	/*************************************************************************
	* 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 87	skipping to change at line 87
	Iter_t fIterator;	Iter_t fIterator;
	T& iter() { return fIterator; }	T& iter() { return fIterator; }
	static void *Create() {	static void *Create() {
	return new Environ();	return new Environ();
	}	}
	};	};
	#else	#else
	struct EnvironBase;	struct EnvironBase;
	template <typename T> struct Environ;	template <typename T> struct Environ;
	#endif	#endif

	#if defined(R__VCXX6)
	template <class T> void Destruct(T* obj) { obj->~T(); }
	#endif

	template <class T, class Q> struct PairHolder {	template <class T, class Q> struct PairHolder {
	T first;	T first;
	Q second;	Q second;
	PairHolder() {}	PairHolder() {}
	PairHolder(const PairHolder& c) : first(c.first), second(c.second) {}	PairHolder(const PairHolder& c) : first(c.first), second(c.second) {}
	virtual ~PairHolder() {}	virtual ~PairHolder() {}
	private:	private:
	PairHolder& operator=(const PairHolder&); // not implemented	PairHolder& operator=(const PairHolder&); // not implemented
	};	};

	skipping to change at line 164	skipping to change at line 161
	}	}
	static void* next(void* env) {	static void* next(void* env) {
	PEnv_t e = PEnv_t(env);	PEnv_t e = PEnv_t(env);
	PCont_t c = PCont_t(e->fObject);	PCont_t c = PCont_t(e->fObject);
	for (; e->fIdx > 0 && e->iter() != c->end(); ++(e->iter()), --e->f Idx){ }	for (; e->fIdx > 0 && e->iter() != c->end(); ++(e->iter()), --e->f Idx){ }
	// TODO: Need to find something for going backwards....	// TODO: Need to find something for going backwards....
	if ( e->iter() == c->end() ) return 0;	if ( e->iter() == c->end() ) return 0;
	TYPENAME T::const_reference ref = *(e->iter());	TYPENAME T::const_reference ref = *(e->iter());
	return Type<T>::address(ref);	return Type<T>::address(ref);
	}	}

	static void* construct(void* env) {	static void* construct(void *what, size_t size) {
	PEnv_t e = PEnv_t(env);	PValue_t m = PValue_t(what);
	PValue_t m = PValue_t(e->fStart);	for (size_t i=0; i<size; ++i, ++m)
	for (size_t i=0; i<e->fSize; ++i, ++m)
	::new(m) Value_t();	::new(m) Value_t();
	return 0;	return 0;
	}	}
	static void* collect(void* env) {	static void* collect(void* env) {
	PEnv_t e = PEnv_t(env);	PEnv_t e = PEnv_t(env);
	PCont_t c = PCont_t(e->fObject);	PCont_t c = PCont_t(e->fObject);
	PValue_t m = PValue_t(e->fStart);	PValue_t m = PValue_t(e->fStart);
	for (Iter_t i=c->begin(); i != c->end(); ++i, ++m )	for (Iter_t i=c->begin(); i != c->end(); ++i, ++m )
	::new(m) Value_t(*i);	::new(m) Value_t(*i);
	return 0;	return 0;
	}	}

	static void* destruct(void* env) {	static void destruct(void *what, size_t size) {
	PEnv_t e = PEnv_t(env);	PValue_t m = PValue_t(what);
	PValue_t m = PValue_t(e->fStart);	for (size_t i=0; i < size; ++i, ++m )
	#if defined(R__VCXX6)
	PCont_t c = PCont_t(e->fObject);
	for (size_t i=0; i < e->fSize; ++i, ++m )
	ROOT::Destruct(m);
	#else
	for (size_t i=0; i < e->fSize; ++i, ++m )
	m->~Value_t();	m->~Value_t();

	#endif
	return 0;
	}	}
	};	};

	/** @class TCollectionProxyInfo::Map TCollectionProxyInfo.h TCollectionP roxyInfo.h	/** @class TCollectionProxyInfo::Map TCollectionProxyInfo.h TCollectionP roxyInfo.h
	*	*
	* Small helper to encapsulate all necessary data accesses for	* Small helper to encapsulate all necessary data accesses for
	* containers like vector, list, deque	* containers like vector, list, deque
	*	*
	* @author M.Frank	* @author M.Frank
	* @version 1.0	* @version 1.0
	* @date 10/10/2004	* @date 10/10/2004
	*/	*/
	template <class T> struct Pushback : public Type<T> {	template <class T> struct Pushback : public Type<T> {
	typedef T Cont_t;	typedef T Cont_t;
	typedef typename T::iterator Iter_t;	typedef typename T::iterator Iter_t;
	typedef typename T::value_type Value_t;	typedef typename T::value_type Value_t;
	typedef Environ<Iter_t> Env_t;	typedef Environ<Iter_t> Env_t;
	typedef Env_t *PEnv_t;	typedef Env_t *PEnv_t;
	typedef Cont_t *PCont_t;	typedef Cont_t *PCont_t;
	typedef Value_t *PValue_t;	typedef Value_t *PValue_t;

	static void* resize(void* env) {	static void resize(void* obj, size_t n) {
	PEnv_t e = PEnv_t(env);	PCont_t c = PCont_t(obj);
	PCont_t c = PCont_t(e->fObject);	c->resize(n);
	c->resize(e->fSize);	}
	e->fIdx = 0;	static void* feed(void from, void to, size_t size) {
	return e->fStart = e->fSize ? Type<T>::address(*c->begin()) : 0;	PCont_t c = PCont_t(to);
	}	PValue_t m = PValue_t(from);
	static void* feed(void* env) {	for (size_t i=0; i<size; ++i, ++m)
	PEnv_t e = PEnv_t(env);
	PCont_t c = PCont_t(e->fObject);
	PValue_t m = PValue_t(e->fStart); // Here start is actually a 'buf
	fer' outside the buffer.
	for (size_t i=0; i<e->fSize; ++i, ++m)
	c->push_back(*m);	c->push_back(*m);
	return 0;	return 0;
	}	}
	static int value_offset() {	static int value_offset() {
	return 0;	return 0;
	}	}
	};	};

	/** @class TCollectionProxyInfo::Map TCollectionProxyInfo.h TCollectionP roxyInfo.h	/** @class TCollectionProxyInfo::Map TCollectionProxyInfo.h TCollectionP roxyInfo.h
	*	*

	skipping to change at line 248	skipping to change at line 232
	* @date 10/10/2004	* @date 10/10/2004
	*/	*/
	template <class T> struct Insert : public Type<T> {	template <class T> struct Insert : public Type<T> {
	typedef T Cont_t;	typedef T Cont_t;
	typedef typename T::iterator Iter_t;	typedef typename T::iterator Iter_t;
	typedef typename T::value_type Value_t;	typedef typename T::value_type Value_t;
	typedef Environ<Iter_t> Env_t;	typedef Environ<Iter_t> Env_t;
	typedef Env_t *PEnv_t;	typedef Env_t *PEnv_t;
	typedef Cont_t *PCont_t;	typedef Cont_t *PCont_t;
	typedef Value_t *PValue_t;	typedef Value_t *PValue_t;

	static void* feed(void* env) {	static void* feed(void from, void to, size_t size) {
	PEnv_t e = PEnv_t(env);	PCont_t c = PCont_t(to);
	PCont_t c = PCont_t(e->fObject);	PValue_t m = PValue_t(from);
	PValue_t m = PValue_t(e->fStart);	for (size_t i=0; i<size; ++i, ++m)
	for (size_t i=0; i<e->fSize; ++i, ++m)
	c->insert(*m);	c->insert(*m);
	return 0;	return 0;
	}	}

	static void* resize(void* /* env */ ) {	static void resize(void* /* obj */, size_t ) {
	return 0;	;
	}	}
	static int value_offset() {	static int value_offset() {
	return 0;	return 0;
	}	}
	};	};

	/** @class TCollectionProxyInfo::Map TCollectionProxyInfo.h TCollectionP roxyInfo.h	/** @class TCollectionProxyInfo::Map TCollectionProxyInfo.h TCollectionP roxyInfo.h
	*	*
	* Small helper to encapsulate all necessary data accesses for	* Small helper to encapsulate all necessary data accesses for
	* containers like set, multiset etc.	* containers like set, multiset etc.

	skipping to change at line 281	skipping to change at line 264
	* @date 10/10/2004	* @date 10/10/2004
	*/	*/
	template <class T> struct MapInsert : public Type<T> {	template <class T> struct MapInsert : public Type<T> {
	typedef T Cont_t;	typedef T Cont_t;
	typedef typename T::iterator Iter_t;	typedef typename T::iterator Iter_t;
	typedef typename T::value_type Value_t;	typedef typename T::value_type Value_t;
	typedef Environ<Iter_t> Env_t;	typedef Environ<Iter_t> Env_t;
	typedef Env_t *PEnv_t;	typedef Env_t *PEnv_t;
	typedef Cont_t *PCont_t;	typedef Cont_t *PCont_t;
	typedef Value_t *PValue_t;	typedef Value_t *PValue_t;

	static void* feed(void* env) {	static void* feed(void from, void to, size_t size) {
	PEnv_t e = PEnv_t(env);	PCont_t c = PCont_t(to);
	PCont_t c = PCont_t(e->fObject);	PValue_t m = PValue_t(from);
	PValue_t m = PValue_t(e->fStart);	for (size_t i=0; i<size; ++i, ++m)
	for (size_t i=0; i<e->fSize; ++i, ++m)
	c->insert(*m);	c->insert(*m);
	return 0;	return 0;
	}	}

	static void* resize(void* /* env */ ) {	static void resize(void* /* obj */, size_t ) {
	return 0;	;
	}	}
	static int value_offset() {	static int value_offset() {
	return ((char)&((PValue_t(0x1000))->second)) - ((char)PValue_t(0 x1000));	return ((char)&((PValue_t(0x1000))->second)) - ((char)PValue_t(0 x1000));
	}	}
	};	};

	public:	public:
	#ifndef __CINT__	#ifndef __CINT__
	const type_info &fInfo;	const type_info &fInfo;
	#endif	#endif
	size_t fIterSize;	size_t fIterSize;
	size_t fValueDiff;	size_t fValueDiff;
	int fValueOffset;	int fValueOffset;
	void* (fSizeFunc)(void);	void* (fSizeFunc)(void);

	void* (fResizeFunc)(void);	void (fResizeFunc)(void,size_t);
	void* (fClearFunc)(void);	void* (fClearFunc)(void);
	void* (fFirstFunc)(void);	void* (fFirstFunc)(void);
	void* (fNextFunc)(void);	void* (fNextFunc)(void);

	void* (fConstructFunc)(void);	void* (fConstructFunc)(void,size_t);
	void* (fDestructFunc)(void);	void (fDestructFunc)(void,size_t);
	void* (fFeedFunc)(void);	void* (fFeedFunc)(void,void*,size_t);
	void* (fCollectFunc)(void);	void* (fCollectFunc)(void);
	void* (*fCreateEnv)();	void* (*fCreateEnv)();


		// Set of function of direct iteration of the collections.
		void (fGetIterators)(void collection, void &begin_arena, void &en
		d_arena);
		// begin_arena and end_arena should contain the location of memory ar
		ena of size fgIteratorSize.
		// If the collection iterator are of that size or less, the iterators
		will be constructed in place in those location (new with placement)
		// Otherwise the iterators will be allocated via a regular new and th
		eir address returned by modifying the value of begin_arena and end_arena.

		void (fCopyIterator)(void &dest, const void *source);
		// Copy the iterator source, into dest. dest should contain should
		contain the location of memory arena of size fgIteratorSize.
		// If the collection iterator are of that size or less, the iterator
		will be constructed in place in this location (new with placement)
		// Otherwise the iterator will be allocated via a regular new and its
		address returned by modifying the value of dest.

		void* (fNext)(void iter, void *end);
		// iter and end should be pointer to respectively an iterator to be i
		ncremented and the result of colleciton.end()
		// 'Next' will increment the iterator 'iter' and return 0 if the iter
		ator reached the end.
		// If the end is not reached, 'Next' will return the address of the c
		ontent unless the collection contains pointers in
		// which case 'Next' will return the value of the pointer.

		void (fDeleteSingleIterator)(void iter);
		void (fDeleteTwoIterators)(void begin, void *end);
		// If the sizeof iterator is greater than fgIteratorArenaSize, call d
		elete on the addresses,
		// Otherwise just call the iterator's destructor.

	public:	public:
	TCollectionProxyInfo(const type_info& info,	TCollectionProxyInfo(const type_info& info,
	size_t iter_size,	size_t iter_size,
	size_t value_diff,	size_t value_diff,
	int value_offset,	int value_offset,
	void* (size_func)(void),	void* (size_func)(void),

	void* (resize_func)(void),	void (resize_func)(void,size_t),
	void* (clear_func)(void),	void* (clear_func)(void),
	void* (first_func)(void),	void* (first_func)(void),
	void* (next_func)(void),	void* (next_func)(void),

	void* (construct_func)(void),	void* (construct_func)(void,size_t),
	void* (destruct_func)(void),	void (destruct_func)(void,size_t),
	void* (feed_func)(void),	void* (feed_func)(void,void*,size_t),
	void* (collect_func)(void),	void* (collect_func)(void),
	void* (*create_env)()	void* (*create_env)()
	) :	) :
	fInfo(info), fIterSize(iter_size), fValueDiff(value_diff),	fInfo(info), fIterSize(iter_size), fValueDiff(value_diff),
	fValueOffset(value_offset),	fValueOffset(value_offset),
	fSizeFunc(size_func),fResizeFunc(resize_func),fClearFunc(clear_fun c),	fSizeFunc(size_func),fResizeFunc(resize_func),fClearFunc(clear_fun c),
	fFirstFunc(first_func),fNextFunc(next_func),fConstructFunc(constru ct_func),	fFirstFunc(first_func),fNextFunc(next_func),fConstructFunc(constru ct_func),
	fDestructFunc(destruct_func),fFeedFunc(feed_func),fCollectFunc(col lect_func),	fDestructFunc(destruct_func),fFeedFunc(feed_func),fCollectFunc(col lect_func),

	fCreateEnv(create_env)	fCreateEnv(create_env),
		fGetIterators(0),fCopyIterator(0),fNext(0),fDeleteSingleIterator(0
		),fDeleteTwoIterators(0)
	{	{
	}	}

	/// Generate proxy from template	/// Generate proxy from template
	template <class T> static ROOT::TCollectionProxyInfo* Generate(const T&) {	template <class T> static ROOT::TCollectionProxyInfo* Generate(const T&) {
	// Generate a TCollectionProxyInfo given a TCollectionProxyInfo::T ype	// Generate a TCollectionProxyInfo given a TCollectionProxyInfo::T ype
	// template (used to described the behavior of the stl collection.	// template (used to described the behavior of the stl collection.
	// Typical use looks like:	// Typical use looks like:
	// ::ROOT::TCollectionProxyInfo::Generate(TCollectionProxyInf o::Pushback< vector<string> >()));	// ::ROOT::TCollectionProxyInfo::Generate(TCollectionProxyInf o::Pushback< vector<string> >()));


	skipping to change at line 435	skipping to change at line 440
	e->fSize = c->size();	e->fSize = c->size();
	return 0;	return 0;
	}	}
	static void* next(void* env) {	static void* next(void* env) {
	PEnv_t e = PEnv_t(env);	PEnv_t e = PEnv_t(env);
	PCont_t c = PCont_t(e->fObject);	PCont_t c = PCont_t(e->fObject);
	for (; e->fIdx > 0 && e->iter() != c->end(); ++(e->iter()), --e->f Idx){ }	for (; e->fIdx > 0 && e->iter() != c->end(); ++(e->iter()), --e->f Idx){ }
	// TODO: Need to find something for going backwards....	// TODO: Need to find something for going backwards....
	return 0;	return 0;
	}	}

	static void* construct(void*) {	static void* construct(void*,size_t) {
	// Nothing to construct.	// Nothing to construct.
	return 0;	return 0;
	}	}
	static void* collect(void* env) {	static void* collect(void* env) {
	PEnv_t e = PEnv_t(env);	PEnv_t e = PEnv_t(env);
	PCont_t c = PCont_t(e->fObject);	PCont_t c = PCont_t(e->fObject);
	PValue_t m = PValue_t(e->fStart); // 'start' is a buffer outside t he container.	PValue_t m = PValue_t(e->fStart); // 'start' is a buffer outside t he container.
	for (Iter_t i=c->begin(); i != c->end(); ++i, ++m )	for (Iter_t i=c->begin(); i != c->end(); ++i, ++m )
	::new(m) Value_t(*i);	::new(m) Value_t(*i);
	return 0;	return 0;
	}	}

	static void* destruct(void*) {	static void destruct(void*,size_t) {
	// Nothing to destruct.	// Nothing to destruct.

	return 0;
	}	}
	};	};

	template <> struct TCollectionProxyInfo::Pushback<std::vector<bool> > : public TCollectionProxyInfo::Type<std::vector<bool> > {	template <> struct TCollectionProxyInfo::Pushback<std::vector<bool> > : public TCollectionProxyInfo::Type<std::vector<bool> > {
	typedef std::vector<bool> Cont_t;	typedef std::vector<bool> Cont_t;
	typedef Cont_t::iterator Iter_t;	typedef Cont_t::iterator Iter_t;
	typedef Cont_t::value_type Value_t;	typedef Cont_t::value_type Value_t;
	typedef Environ<Iter_t> Env_t;	typedef Environ<Iter_t> Env_t;
	typedef Env_t *PEnv_t;	typedef Env_t *PEnv_t;
	typedef Cont_t *PCont_t;	typedef Cont_t *PCont_t;
	typedef Value_t *PValue_t;	typedef Value_t *PValue_t;


	static void* resize(void* env) {	static void resize(void* obj,size_t n) {
	PEnv_t e = PEnv_t(env);	PCont_t c = PCont_t(obj);
	PCont_t c = PCont_t(e->fObject);	c->resize(n);
	c->resize(e->fSize);	}
	e->fIdx = 0;	static void* feed(void* from, void *to, size_t size) {
	return 0;	PCont_t c = PCont_t(to);
	}	PValue_t m = PValue_t(from);
	static void* feed(void* env) {	for (size_t i=0; i<size; ++i, ++m)
	PEnv_t e = PEnv_t(env);
	PCont_t c = PCont_t(e->fObject);
	PValue_t m = PValue_t(e->fStart); // Here start is actually a 'buf
	fer' outside the container.
	for (size_t i=0; i<e->fSize; ++i, ++m)
	c->push_back(*m);	c->push_back(*m);
	return 0;	return 0;
	}	}
	static int value_offset() {	static int value_offset() {
	return 0;	return 0;
	}	}
	};	};

	#ifndef __CINT__	#ifndef __CINT__
	// Need specialization for boolean references due to stupid STL vector<b ool>	// Need specialization for boolean references due to stupid STL vector<b ool>

	skipping to change at line 536	skipping to change at line 536
	e->fSize = c->size();	e->fSize = c->size();
	return 0;	return 0;
	}	}
	static void* next(void* env) {	static void* next(void* env) {
	PEnv_t e = PEnv_t(env);	PEnv_t e = PEnv_t(env);
	PCont_t c = PCont_t(e->fObject);	PCont_t c = PCont_t(e->fObject);
	for (; e->fIdx > 0 && e->fIterator.first != c->size(); ++(e->fIter ator.first), --e->fIdx){ }	for (; e->fIdx > 0 && e->fIterator.first != c->size(); ++(e->fIter ator.first), --e->fIdx){ }
	e->fIterator.second = (e->fIterator.first != c->size()) ? c->test( e->fIterator.first) : false;	e->fIterator.second = (e->fIterator.first != c->size()) ? c->test( e->fIterator.first) : false;
	return 0;	return 0;
	}	}

	static void* construct(void*) {	static void* construct(void*,size_t) {
	// Nothing to construct.	// Nothing to construct.
	return 0;	return 0;
	}	}
	static void* collect(void* env) {	static void* collect(void* env) {
	PEnv_t e = PEnv_t(env);	PEnv_t e = PEnv_t(env);
	PCont_t c = PCont_t(e->fObject);	PCont_t c = PCont_t(e->fObject);
	PValue_t m = PValue_t(e->fStart); // 'start' is a buffer outside t he container.	PValue_t m = PValue_t(e->fStart); // 'start' is a buffer outside t he container.
	for (size_t i=0; i != c->size(); ++i, ++m )	for (size_t i=0; i != c->size(); ++i, ++m )
	*m = c->test(i);	*m = c->test(i);
	return 0;	return 0;
	}	}

	static void* destruct(void*) {	static void destruct(void*,size_t) {
	// Nothing to destruct.	// Nothing to destruct.

	return 0;
	}	}
	};	};

	template <typename Bitset_t>	template <typename Bitset_t>
	struct TCollectionProxyInfo::Pushback<ROOT::TStdBitsetHelper<Bitset_t> > : public TCollectionProxyInfo::Type<TStdBitsetHelper<Bitset_t> > {	struct TCollectionProxyInfo::Pushback<ROOT::TStdBitsetHelper<Bitset_t> > : public TCollectionProxyInfo::Type<TStdBitsetHelper<Bitset_t> > {
	typedef Bitset_t Cont_t;	typedef Bitset_t Cont_t;
	typedef bool Iter_t;	typedef bool Iter_t;
	typedef bool Value_t;	typedef bool Value_t;
	typedef Environ<Iter_t> Env_t;	typedef Environ<Iter_t> Env_t;
	typedef Env_t *PEnv_t;	typedef Env_t *PEnv_t;
	typedef Cont_t *PCont_t;	typedef Cont_t *PCont_t;
	typedef Value_t *PValue_t;	typedef Value_t *PValue_t;


	static void* resize(void* env) {	static void resize(void*,size_t) {
	PEnv_t e = PEnv_t(env);
	e->fIdx = 0;
	return 0;
	}	}

	static void* feed(void* env) {	static void* feed(void from, void to, size_t size) {
	PEnv_t e = PEnv_t(env);	PCont_t c = PCont_t(to);
	PCont_t c = PCont_t(e->fObject);	PValue_t m = PValue_t(from);
	PValue_t m = PValue_t(e->fStart); // Here start is actually a 'buf	for (size_t i=0; i<size; ++i, ++m)
	fer' outside the container.
	for (size_t i=0; i<e->fSize; ++i, ++m)
	c->set(i,*m);	c->set(i,*m);
	return 0;	return 0;
	}	}
	static int value_offset() {	static int value_offset() {
	return 0;	return 0;
	}	}
	};	};
	#endif	#endif

	}	}

End of changes. 25 change blocks.
	84 lines changed or deleted	88 lines changed or added

	TEfficiency.h	TEfficiency.h
	#ifndef ROOT_TEfficiency	#ifndef ROOT_TEfficiency
	#define ROOT_TEfficiency	#define ROOT_TEfficiency

	//standard header	//standard header
	#include <vector>	#include <vector>

		#include <utility>

	//ROOT header	//ROOT header
	#ifndef ROOT_TNamed	#ifndef ROOT_TNamed
	#include "TNamed.h"	#include "TNamed.h"
	#endif	#endif

	#ifndef ROOT_TAttLine	#ifndef ROOT_TAttLine
	#include "TAttLine.h"	#include "TAttLine.h"
	#endif	#endif


	skipping to change at line 38	skipping to change at line 39
	class TList;	class TList;

	//\|TEfficiency	//\|TEfficiency
	//------------------------	//------------------------

	class TEfficiency: public TNamed, public TAttLine, public TAttFill, public TAttMarker	class TEfficiency: public TNamed, public TAttLine, public TAttFill, public TAttMarker
	{	{
	public:	public:
	//enumaration type for different statistic options for calculating co nfidence intervals	//enumaration type for different statistic options for calculating co nfidence intervals
	//kF* ... frequentist methods; kB* ... bayesian methods	//kF* ... frequentist methods; kB* ... bayesian methods

	enum {	enum EStatOption {
	kFCP, //Clopper-Pearson interval (recom	kFCP = 0, //Clopper-Pearson interval (r
	mended by PDG)	ecommended by PDG)
	kFNormal, //normal approximation	kFNormal, //normal approximation
	kFWilson, //Wilson interval	kFWilson, //Wilson interval
	kFAC, //Agresti-Coull interval	kFAC, //Agresti-Coull interval

		kFFC, //Feldman-Cousins interval
	kBJeffrey, //Jeffrey interval (Prior ~ Beta( 0.5,0.5)	kBJeffrey, //Jeffrey interval (Prior ~ Beta( 0.5,0.5)
	kBUniform, //Prior ~ Uniform = Beta(1,1)	kBUniform, //Prior ~ Uniform = Beta(1,1)
	kBBayesian //user specified Prior ~ Beta(fBe ta_alpha,fBeta_beta)	kBBayesian //user specified Prior ~ Beta(fBe ta_alpha,fBeta_beta)
	};	};

	protected:	protected:


	Double_t fBeta_alpha; //parameter for prior beta dis	Double_t fBeta_alpha; //global parameter for prior b
	tribution (default = 1)	eta distribution (default = 1)
	Double_t fBeta_beta; //parameter for prior beta dis	Double_t fBeta_beta; //global parameter for prior b
	tribution (default = 1)	eta distribution (default = 1)
		std::vector<std::pair<Double_t, Double_t> > fBeta_bin_params; // par
		ameter for prior beta distribution different bin by bin
		// (defaul
		t vector is empty)
	Double_t (*fBoundary)(Int_t,Int_t,Double_t,Bool_t); //!pointer to a method calculating the boundaries of confidence intervals	Double_t (*fBoundary)(Int_t,Int_t,Double_t,Bool_t); //!pointer to a method calculating the boundaries of confidence intervals
	Double_t fConfLevel; //confidence level (default = 0.95)	Double_t fConfLevel; //confidence level (default = 0.95)
	TDirectory* fDirectory; //!pointer to directory holdin g this TEfficiency object	TDirectory* fDirectory; //!pointer to directory holdin g this TEfficiency object
	TList* fFunctions; //->pointer to list of functio ns	TList* fFunctions; //->pointer to list of functio ns
	TGraphAsymmErrors* fPaintGraph; //!temporary graph for paintin g	TGraphAsymmErrors* fPaintGraph; //!temporary graph for paintin g
	TH1* fPaintHisto; //!temporary histogram for pai nting	TH1* fPaintHisto; //!temporary histogram for pai nting
	TH1* fPassedHistogram; //histogram for events which p assed certain criteria	TH1* fPassedHistogram; //histogram for events which p assed certain criteria

	Int_t fStatisticOption; //defines how the confidence i ntervals are determined	EStatOption fStatisticOption; //defines how the confidence i ntervals are determined
	TH1* fTotalHistogram; //histogram for total number o f events	TH1* fTotalHistogram; //histogram for total number o f events
	Double_t fWeight; //weight for all events (defau lt = 1)	Double_t fWeight; //weight for all events (defau lt = 1)

	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)
		kShortestInterval = BIT(16), // use shortest interval
		kUseBinPrior = BIT(17) // use a different prior
		for each bin
	};	};

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

	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,

	skipping to change at line 91	skipping to change at line 98
	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;}

	void Draw(const Option_t* opt="");	void Draw(Option_t* opt);
	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);
	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="");

	Double_t GetBetaAlpha() const {return fBeta_alpha;}	// use trick of -1 to return global parameters
	Double_t GetBetaBeta() const {return fBeta_beta;}	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 GetConfidenceLevel() const {return fConfLevel;}	Double_t GetConfidenceLevel() const {return fConfLevel;}
	TH1* GetCopyPassedHisto() const;	TH1* GetCopyPassedHisto() const;
	TH1* GetCopyTotalHisto() const;	TH1* GetCopyTotalHisto() const;
	Int_t GetDimension() const;	Int_t GetDimension() const;
	TDirectory* GetDirectory() const {return fDirectory;}	TDirectory* GetDirectory() const {return fDirectory;}
	Double_t GetEfficiency(Int_t bin) const;	Double_t GetEfficiency(Int_t bin) const;
	Double_t GetEfficiencyErrorLow(Int_t bin) const;	Double_t GetEfficiencyErrorLow(Int_t bin) const;
	Double_t GetEfficiencyErrorUp(Int_t bin) const;	Double_t GetEfficiencyErrorUp(Int_t bin) const;
	Int_t GetGlobalBin(Int_t binx,Int_t biny=0,Int_t binz=0) cons t;	Int_t GetGlobalBin(Int_t binx,Int_t biny=0,Int_t binz=0) cons t;
	TList* GetListOfFunctions() const {return fFunctions;}	TList* GetListOfFunctions() const {return fFunctions;}
	const TH1* GetPassedHistogram() const {return fPassedHistogram;}	const TH1* GetPassedHistogram() const {return fPassedHistogram;}

	Int_t GetStatisticOption() const {return fStatisticOption;}	EStatOption GetStatisticOption() const {return fStatisticOption;}
	const TH1* GetTotalHistogram() const {return fTotalHistogram;}	const TH1* GetTotalHistogram() const {return fTotalHistogram;}
	Double_t GetWeight() const {return fWeight;}	Double_t GetWeight() const {return fWeight;}
	void Merge(TCollection* list);	void Merge(TCollection* list);
	TEfficiency& operator+=(const TEfficiency& rhs);	TEfficiency& operator+=(const TEfficiency& rhs);
	TEfficiency& operator=(const TEfficiency& rhs);	TEfficiency& operator=(const TEfficiency& rhs);

	void Paint(const Option_t* opt);	void Paint(Option_t* opt);
	void SavePrimitive(ostream& out,Option_t* opt="");	void SavePrimitive(ostream& out,Option_t* opt="");
	void SetBetaAlpha(Double_t alpha);	void SetBetaAlpha(Double_t alpha);
	void SetBetaBeta(Double_t beta);	void SetBetaBeta(Double_t beta);

		void SetBetaBinParameters(Int_t bin, Double_t alpha, Double_ t beta);
	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 SetStatisticOption(Int_t option);	void SetPosteriorMode(Bool_t on = true) { SetBit(kPosteriorM
		ode,on); if(on) SetShortestInterval(); }
		void SetPosteriorAverage(Bool_t on = true) { SetBit(kPosteri
		orMode,!on); }
		void SetShortestInterval(Bool_t on = true) { SetBit(kShortes
		tInterval,on); }
		void SetCentralInterval(Bool_t on = true) { SetBit(kShortest
		Interval,!on); }
		void SetStatisticOption(EStatOption option);
	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 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 UsesShortestInterval() const {return TestBit(kShortes
		tInterval) && TestBit(kIsBayesian);}
		Bool_t UsesPosteriorAverage() const {return !UsesPosteriorMo
		de();}
		Bool_t UsesCentralInterval() const {return !UsesShortestInte
		rval();}

	static Bool_t CheckBinning(const TH1& pass,const TH1& total);	static Bool_t CheckBinning(const TH1& pass,const TH1& total);
	static Bool_t CheckConsistency(const TH1& pass,const TH1& total,Optio n_t* opt="");	static Bool_t CheckConsistency(const TH1& pass,const TH1& total,Optio n_t* opt="");
	static Bool_t CheckEntries(const TH1& pass,const TH1& total,Option_t* opt="");	static Bool_t CheckEntries(const TH1& pass,const TH1& total,Option_t* opt="");
	static Double_t Combine(Double_t& up,Double_t& low,Int_t n,const Int_ t* pass,const Int_t* total,	static Double_t Combine(Double_t& up,Double_t& low,Int_t n,const Int_ t* pass,const Int_t* total,

	const Double_t* alpha,const Double_t* beta,Dou ble_t level=0.683,	Double_t alpha,Double_t beta,Double_t level=0. 683,
	const Double_t* w=0,Option_t* opt="");	const Double_t* w=0,Option_t* opt="");

	static TGraphAsymmErrors* Combine(TCollection* pList,Option_t* opt="N ",Int_t n=0,const Double_t* w=0);	static TGraphAsymmErrors* Combine(TCollection* pList,Option_t* opt="" ,Int_t n=0,const Double_t* w=0);

	//calculating boundaries of confidence intervals	//calculating boundaries of confidence intervals
	static Double_t AgrestiCoull(Int_t total,Int_t passed,Double_t level, Bool_t bUpper);	static Double_t AgrestiCoull(Int_t total,Int_t passed,Double_t level, Bool_t bUpper);

	static Double_t Bayesian(Int_t total,Int_t passed,Double_t level,Doub le_t alpha,Double_t beta,Bool_t bUpper);
	static Double_t ClopperPearson(Int_t total,Int_t passed,Double_t leve l,Bool_t bUpper);	static Double_t ClopperPearson(Int_t total,Int_t passed,Double_t leve l,Bool_t bUpper);
	static Double_t Normal(Int_t total,Int_t passed,Double_t level,Bool_t bUpper);	static Double_t Normal(Int_t total,Int_t passed,Double_t level,Bool_t bUpper);
	static Double_t Wilson(Int_t total,Int_t passed,Double_t level,Bool_t bUpper);	static Double_t Wilson(Int_t total,Int_t passed,Double_t level,Bool_t bUpper);

		static Double_t FeldmanCousins(Int_t total,Int_t passed,Double_t leve
		l,Bool_t bUpper);
		static Bool_t FeldmanCousinsInterval(Int_t total,Int_t passed,Double_
		t level,Double_t & lower, Double_t & upper);
		// Bayesian functions
		static Double_t Bayesian(Int_t total,Int_t passed,Double_t level,Doub
		le_t alpha,Double_t beta,Bool_t bUpper, Bool_t bShortest = false);
		// helper functions for Bayesian statistics
		static Double_t BetaCentralInterval(Double_t level,Double_t alpha,Dou
		ble_t beta,Bool_t bUpper);
		static Bool_t BetaShortestInterval(Double_t level,Double_t alpha,Do
		uble_t beta,Double_t & lower, Double_t & upper);
		static Double_t BetaMean(Double_t alpha,Double_t beta);
		static Double_t BetaMode(Double_t alpha,Double_t beta);

	ClassDef(TEfficiency,1) //calculating efficiencies	ClassDef(TEfficiency,1) //calculating efficiencies
	};	};

	const TEfficiency operator+(const TEfficiency& lhs,const TEfficiency& rhs);	const TEfficiency operator+(const TEfficiency& lhs,const TEfficiency& rhs);

	#endif	#endif

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

	TEmulatedMapProxy.h	TEmulatedMapProxy.h

	// @(#)root/io:$Id: TEmulatedMapProxy.h 23122 2008-04-10 14:56:30Z rdm $	// @(#)root/io:$Id: TEmulatedMapProxy.h 36061 2010-10-04 16:05:51Z pcanal $
	// Author: Markus Frank 28/10/04	// Author: Markus Frank 28/10/04

	/*************************************************************************	/*************************************************************************
	* 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. *
	*************************************************************************/	*************************************************************************/
	#ifndef ROOT_TEmulatedMapProxy	#ifndef ROOT_TEmulatedMapProxy

	skipping to change at line 53	skipping to change at line 53

	// Standard destructor	// Standard destructor
	virtual ~TEmulatedMapProxy();	virtual ~TEmulatedMapProxy();

	// Return the address of the value at index 'idx'	// Return the address of the value at index 'idx'
	virtual void *At(UInt_t idx);	virtual void *At(UInt_t idx);

	// Return the current size of the container	// Return the current size of the container
	virtual UInt_t Size() const;	virtual UInt_t Size() const;


		// Read portion of the streamer
		virtual void ReadBuffer(TBuffer &buff, void *pObj);
		virtual void ReadBuffer(TBuffer &buff, void pObj, const TClass onfile)
		;

	// Streamer for I/O handling	// Streamer for I/O handling
	virtual void Streamer(TBuffer &refBuffer);	virtual void Streamer(TBuffer &refBuffer);

	// Streamer I/O overload	// Streamer I/O overload
	virtual void Streamer(TBuffer &buff, void *pObj, int siz) {	virtual void Streamer(TBuffer &buff, void *pObj, int siz) {
	TEmulatedCollectionProxy::Streamer(buff,pObj,siz);	TEmulatedCollectionProxy::Streamer(buff,pObj,siz);
	}	}
	};	};

	#endif	#endif

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

	TEveBoxGL.h	TEveBoxGL.h

	// @(#)root/eve:$Id: TEveBoxGL.h 32528 2010-03-10 17:02:54Z matevz $	// @(#)root/eve:$Id: TEveBoxGL.h 36867 2010-11-23 10:06:35Z matevz $
	// Author: Matevz Tadel, 2010	// Author: Matevz Tadel, 2010

	/*************************************************************************	/*************************************************************************
	* 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 50	skipping to change at line 50
	public:	public:
	TEveBoxGL();	TEveBoxGL();
	virtual ~TEveBoxGL() {}	virtual ~TEveBoxGL() {}

	virtual Bool_t SetModel(TObject* obj, const Option_t* opt=0);	virtual Bool_t SetModel(TObject* obj, const Option_t* opt=0);
	virtual void SetBBox();	virtual void SetBBox();

	virtual void Draw(TGLRnrCtx& rnrCtx) const;	virtual void Draw(TGLRnrCtx& rnrCtx) const;
	virtual void DirectDraw(TGLRnrCtx& rnrCtx) const;	virtual void DirectDraw(TGLRnrCtx& rnrCtx) const;


		virtual Bool_t IgnoreSizeForOfInterest() const { return kTRUE; }

	// To support two-level selection	// To support two-level selection
	// virtual Bool_t SupportsSecondarySelect() const { return kTRUE; }	// virtual Bool_t SupportsSecondarySelect() const { return kTRUE; }
	// virtual void ProcessSelection(TGLRnrCtx & rnrCtx, TGLSelectRecord & r ec);	// virtual void ProcessSelection(TGLRnrCtx & rnrCtx, TGLSelectRecord & r ec);

	ClassDef(TEveBoxGL, 0); // GL renderer class for TEveBox.	ClassDef(TEveBoxGL, 0); // GL renderer class for TEveBox.
	};	};

	//------------------------------------------------------------------------- -----	//------------------------------------------------------------------------- -----
	// TEveBoxProjectedGL	// TEveBoxProjectedGL
	//------------------------------------------------------------------------- -----	//------------------------------------------------------------------------- -----

	skipping to change at line 82	skipping to change at line 84
	public:	public:
	TEveBoxProjectedGL();	TEveBoxProjectedGL();
	virtual ~TEveBoxProjectedGL() {}	virtual ~TEveBoxProjectedGL() {}

	virtual Bool_t SetModel(TObject* obj, const Option_t* opt=0);	virtual Bool_t SetModel(TObject* obj, const Option_t* opt=0);
	virtual void SetBBox();	virtual void SetBBox();

	virtual void Draw(TGLRnrCtx& rnrCtx) const;	virtual void Draw(TGLRnrCtx& rnrCtx) const;
	virtual void DirectDraw(TGLRnrCtx& rnrCtx) const;	virtual void DirectDraw(TGLRnrCtx& rnrCtx) const;


		virtual Bool_t IgnoreSizeForOfInterest() const { return kTRUE; }

	// To support two-level selection	// To support two-level selection
	// virtual Bool_t SupportsSecondarySelect() const { return kTRUE; }	// virtual Bool_t SupportsSecondarySelect() const { return kTRUE; }
	// virtual void ProcessSelection(TGLRnrCtx & rnrCtx, TGLSelectRecord & r ec);	// virtual void ProcessSelection(TGLRnrCtx & rnrCtx, TGLSelectRecord & r ec);

	ClassDef(TEveBoxProjectedGL, 0); // GL renderer class for TEveBoxProject ed.	ClassDef(TEveBoxProjectedGL, 0); // GL renderer class for TEveBoxProject ed.
	};	};

	#endif	#endif

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

	TEveBoxSet.h	TEveBoxSet.h

	// @(#)root/eve:$Id: TEveBoxSet.h 32935 2010-04-09 20:10:18Z matevz $	// @(#)root/eve:$Id: TEveBoxSet.h 37234 2010-12-03 18:20:15Z matevz $
	// 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 29	skipping to change at line 29
	class TRandom;	class TRandom;

	class TEveBoxSet: public TEveDigitSet	class TEveBoxSet: public TEveDigitSet
	{	{
	friend class TEveBoxSetGL;	friend class TEveBoxSetGL;

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

	public:	public:

	enum EBoxType_e	enum EBoxType_e {
	{	kBT_Undef, // unknown-ignored
	kBT_Undef, // unknown-ignored	kBT_FreeBox, // arbitrary box: specify 8*(x,y,z) box corners
	kBT_FreeBox, // arbitrary box: specify 8*(x,y,z) box corne	kBT_AABox, // axis-aligned box: specify (x,y,z) and (w, h,
	rs	d)
	kBT_AABox, // axis-aligned box: specify (x,y,z) and (w,	kBT_AABoxFixedDim, // axis-aligned box w/ fixed dimensions: specify
	h, d)	(x,y,z)
	kBT_AABoxFixedDim, // axis-aligned box w/ fixed dimensions: spec	kBT_Cone,
	ify (x,y,z)	kBT_EllipticCone
	kBT_Cone,	};
	kBT_EllipticCone
	};


	protected:	struct BFreeBox_t : public DigitBase_t { Float_t fVertices[8][3];
		};
	struct BFreeBox_t : public DigitBase_t { Float_t fVertices[24]; };

	struct BOrigin_t : public DigitBase_t { Float_t fA, fB, fC; };	struct BOrigin_t : public DigitBase_t { Float_t fA, fB, fC; };

	struct BAABox_t : public BOrigin_t { Float_t fW, fH, fD; };	struct BAABox_t : public BOrigin_t { Float_t fW, fH, fD; };

	struct BAABoxFixedDim_t : public BOrigin_t {};	struct BAABoxFixedDim_t : public BOrigin_t {};

	struct BCone_t : public DigitBase_t { TEveVector fPos, fDir; Fl oat_t fR; };	struct BCone_t : public DigitBase_t { TEveVector fPos, fDir; Fl oat_t fR; };

	struct BEllipticCone_t : public BCone_t { Float_t fR2, fAngle; };	struct BEllipticCone_t : public BCone_t { Float_t fR2, fAngle; };

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

	TEveBoxSetGL.h	TEveBoxSetGL.h

	// @(#)root/eve:$Id: TEveBoxSetGL.h 33124 2010-04-21 20:04:42Z matevz $	// @(#)root/eve:$Id: TEveBoxSetGL.h 36816 2010-11-20 22:41:48Z matevz $
	// 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 29	skipping to change at line 29
	{	{
	TEveBoxSetGL(const TEveBoxSetGL&); // Not implemented	TEveBoxSetGL(const TEveBoxSetGL&); // Not implemented
	TEveBoxSetGL& operator=(const TEveBoxSetGL&); // Not implemented	TEveBoxSetGL& operator=(const TEveBoxSetGL&); // Not implemented

	protected:	protected:
	TEveBoxSet *fM; // Model object.	TEveBoxSet *fM; // Model object.

	mutable UInt_t fBoxDL; // Display-list id for a box atom.	mutable UInt_t fBoxDL; // Display-list id for a box atom.

	Int_t PrimitiveType() const;	Int_t PrimitiveType() const;

	void MakeOriginBox(Float_t p[24], Float_t dx, Float_t dy, Float_t dz)	void MakeOriginBox(Float_t p[8][3], Float_t dx, Float_t dy, Float_t dz
	const;	) const;
	void RenderBox(const Float_t p[24]) const;	void RenderBoxStdNorm(const Float_t p[8][3]) const;
		void RenderBoxAutoNorm(const Float_t p[8][3]) const;
	void MakeDisplayList() const;	void MakeDisplayList() const;

	void RenderBoxes(TGLRnrCtx& rnrCtx) const;	void RenderBoxes(TGLRnrCtx& rnrCtx) const;

	public:	public:
	TEveBoxSetGL();	TEveBoxSetGL();
	virtual ~TEveBoxSetGL();	virtual ~TEveBoxSetGL();

	virtual Bool_t ShouldDLCache(const TGLRnrCtx& rnrCtx) const;	virtual Bool_t ShouldDLCache(const TGLRnrCtx& rnrCtx) const;
	virtual void DLCacheDrop();	virtual void DLCacheDrop();

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

	TEveCaloLegoGL.h	TEveCaloLegoGL.h

	// @(#)root/eve:$Id: TEveCaloLegoGL.h 35048 2010-08-27 14:39:37Z matevz $	// @(#)root/eve:$Id: TEveCaloLegoGL.h 37345 2010-12-06 16:53:39Z matevz $
	// Author: Alja Mrak-Tadel 2007	// Author: Alja Mrak-Tadel 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 65	skipping to change at line 65
	Float_t Y() { return 0.5*(fY0 + fY1); }	Float_t Y() { return 0.5*(fY0 + fY1); }
	};	};

	typedef std::vector<Cell2D_t> vCell2D_t;	typedef std::vector<Cell2D_t> vCell2D_t;
	typedef std::vector<Cell2D_t>::iterator vCell2D_i;	typedef std::vector<Cell2D_t>::iterator vCell2D_i;

	typedef std::map<Int_t, UInt_t> SliceDLMap_t;	typedef std::map<Int_t, UInt_t> SliceDLMap_t;
	typedef std::map<Int_t, UInt_t>::iterator SliceDLMap_i;	typedef std::map<Int_t, UInt_t>::iterator SliceDLMap_i;

	// histogram base	// histogram base

	mutable Float_t fDataMax;
	mutable Color_t fGridColor;	mutable Color_t fGridColor;
	mutable Color_t fFontColor;	mutable Color_t fFontColor;

	mutable TAxis *fEtaAxis;	mutable TAxis *fEtaAxis;
	mutable TAxis *fPhiAxis;	mutable TAxis *fPhiAxis;
	mutable TAxis *fZAxis;	mutable TAxis *fZAxis;
	mutable TEveVector fXAxisTitlePos;	mutable TEveVector fXAxisTitlePos;
	mutable TEveVector fYAxisTitlePos;	mutable TEveVector fYAxisTitlePos;
	mutable TEveVector fZAxisTitlePos;	mutable TEveVector fZAxisTitlePos;
	mutable TEveVector fBackPlaneXConst[2];	mutable TEveVector fBackPlaneXConst[2];

	skipping to change at line 98	skipping to change at line 97
	mutable Int_t fCurrentPixelsPerBin;	mutable Int_t fCurrentPixelsPerBin;

	mutable SliceDLMap_t fDLMap;	mutable SliceDLMap_t fDLMap;
	mutable Bool_t fCells3D;	mutable Bool_t fCells3D;

	mutable Int_t fBinStep;	mutable Int_t fBinStep;

	TEveCaloLegoGL(const TEveCaloLegoGL&); // Stop default	TEveCaloLegoGL(const TEveCaloLegoGL&); // Stop default
	TEveCaloLegoGL& operator=(const TEveCaloLegoGL&); // Stop default	TEveCaloLegoGL& operator=(const TEveCaloLegoGL&); // Stop default


	protected:	private:
		void GetScaleForMatrix(Float_t& sx, Float_t& sy, Float_t& sz) const;
	Int_t GetGridStep(TGLRnrCtx &rnrCtx) const;	Int_t GetGridStep(TGLRnrCtx &rnrCtx) const;
	void RebinAxis(TAxis orig, TAxis curr) const;	void RebinAxis(TAxis orig, TAxis curr) const;

	void SetAxis3DTitlePos(TGLRnrCtx &rnrCtx, Float_t x0, Float_t x1, Flo at_t y0, Float_t y1) const;	void SetAxis3DTitlePos(TGLRnrCtx &rnrCtx, Float_t x0, Float_t x1, Flo at_t y0, Float_t y1) const;
	void DrawAxis3D(TGLRnrCtx &rnrCtx) const;	void DrawAxis3D(TGLRnrCtx &rnrCtx) const;
	void DrawAxis2D(TGLRnrCtx &rnrCtx) const;	void DrawAxis2D(TGLRnrCtx &rnrCtx) const;
	void DrawHistBase(TGLRnrCtx &rnrCtx) const;	void DrawHistBase(TGLRnrCtx &rnrCtx) const;

	// highlight	// highlight
	void DrawSelectedCells(TGLRnrCtx & rnrCtx, TEveCaloData::vCellId_t ce lls) const;	void DrawSelectedCells(TGLRnrCtx & rnrCtx, TEveCaloData::vCellId_t ce lls) const;

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

	TEveGeoPolyShape.h	TEveGeoPolyShape.h

	// @(#)root/eve:$Id: TEveGeoPolyShape.h 28295 2009-04-20 20:26:34Z matevz $	// @(#)root/eve:$Id: TEveGeoPolyShape.h 37192 2010-12-02 15:54:26Z matevz $
	// Author: Matevz Tadel 2007	// Author: Matevz Tadel 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. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TEveGeoPolyShape	#ifndef ROOT_TEveGeoPolyShape
	#define ROOT_TEveGeoPolyShape	#define ROOT_TEveGeoPolyShape

	#include "TGeoBBox.h"	#include "TGeoBBox.h"

	#include "TAttBBox.h"

	class TBuffer3D;	class TBuffer3D;
	class TGLFaceSet;	class TGLFaceSet;

		class TGeoCompositeShape;

	class TEveGeoPolyShape : public TGeoBBox	class TEveGeoPolyShape : public TGeoBBox
	{	{
	friend class TEveGeoPolyShapeGL;	friend class TEveGeoPolyShapeGL;

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

	protected:	protected:
	std::vector<Double_t> fVertices;	std::vector<Double_t> fVertices;
	std::vector<Int_t> fPolyDesc;	std::vector<Int_t> fPolyDesc;
	UInt_t fNbPols;	UInt_t fNbPols;

	virtual void FillBuffer3D(TBuffer3D& buffer, Int_t reqSections, Bool_t l ocalFrame) const;	virtual void FillBuffer3D(TBuffer3D& buffer, Int_t reqSections, Bool_t l ocalFrame) const;


		struct Edge_t
		{
		Int_t fI, fJ;
		Edge_t(Int_t i, Int_t j)
		{
		if (i <= j) { fI = i; fJ = j; }
		else { fI = j; fJ = i; }
		}

		bool operator<(const Edge_t& e) const
		{
		if (fI == e.fI)
		return fJ < e.fJ;
		else
		return fI < e.fI;
		}
		};

	public:	public:
	TEveGeoPolyShape();	TEveGeoPolyShape();
	virtual ~TEveGeoPolyShape() {}	virtual ~TEveGeoPolyShape() {}


		static TEveGeoPolyShape* Construct(TGeoCompositeShape *cshp, Int_t n_seg
		);

	void SetFromFaceSet(TGLFaceSet* fs);	void SetFromFaceSet(TGLFaceSet* fs);

	virtual const TBuffer3D& GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;	virtual const TBuffer3D& GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;
	virtual TBuffer3D* MakeBuffer3D() const;	virtual TBuffer3D* MakeBuffer3D() const;

	ClassDef(TEveGeoPolyShape, 1); // A shape with arbitrary tesselation for visualization of CSG shapes.	ClassDef(TEveGeoPolyShape, 1); // A shape with arbitrary tesselation for visualization of CSG shapes.
	};	};

	#endif	#endif

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

	TEveGeoShape.h	TEveGeoShape.h

	// @(#)root/eve:$Id: TEveGeoShape.h 35074 2010-08-30 15:18:02Z matevz $	// @(#)root/eve:$Id: TEveGeoShape.h 37192 2010-12-02 15:54:26Z matevz $
	// Author: Matevz Tadel 2007	// Author: Matevz Tadel 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. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TEveGeoShape	#ifndef ROOT_TEveGeoShape
	#define ROOT_TEveGeoShape	#define ROOT_TEveGeoShape


	#include "TEveElement.h"	#include "TEveShape.h"
	#include "TEveProjectionBases.h"
	#include "TAttBBox.h"

	class TGeoShape;	class TGeoShape;

		class TGeoCompositeShape;
	class TEveGeoShapeExtract;	class TEveGeoShapeExtract;
	class TBuffer3D;	class TBuffer3D;


	class TEveGeoShape : public TEveElement,	class TEveGeoShape : public TEveShape
	public TNamed,
	public TEveProjectable
	{	{
	private:	private:
	TEveGeoShape(const TEveGeoShape&); // Not implemented	TEveGeoShape(const TEveGeoShape&); // Not implemented
	TEveGeoShape& operator=(const TEveGeoShape&); // Not implemented	TEveGeoShape& operator=(const TEveGeoShape&); // Not implemented

	protected:	protected:

	Color_t fColor;	Int_t fNSegments;
	Int_t fNSegments;	TGeoShape *fShape;
	TGeoShape* fShape;	TGeoCompositeShape *fCompositeShape; //! Temporary holder (if passed sha
		pe is composite shape).


	static TGeoManager* fgGeoMangeur;	static TGeoManager *fgGeoMangeur;

	static TEveGeoShape* SubImportShapeExtract(TEveGeoShapeExtract* gse, TEv eElement* parent);	static TEveGeoShape* SubImportShapeExtract(TEveGeoShapeExtract* gse, TEv eElement* parent);
	TEveGeoShapeExtract* DumpShapeTree(TEveGeoShape* geon, TEveGeoShapeExtra ct* parent=0);	TEveGeoShapeExtract* DumpShapeTree(TEveGeoShape* geon, TEveGeoShapeExtra ct* parent=0);


		TGeoShape* MakePolyShape();

	public:	public:
	TEveGeoShape(const char* name="TEveGeoShape", const char* title=0);	TEveGeoShape(const char* name="TEveGeoShape", const char* title=0);
	virtual ~TEveGeoShape();	virtual ~TEveGeoShape();


	virtual TObject* GetObject(const TEveException& /eh/="TEveElementList: :GetObject ") const	virtual TObject* GetObject(const TEveException&) const
	{ const TObject* obj = this; return const_cast<TObject*>(obj); }	{ const TObject* obj = this; return const_cast<TObject*>(obj); }


	Color_t GetColor() const { return fColor; }
	Int_t GetNSegments() const { return fNSegments; }	Int_t GetNSegments() const { return fNSegments; }

	void SetNSegments(Int_t s) { fNSegments = s; }	TGeoShape* GetShape() const { return fShape; }
	TGeoShape* GetShape() { return fShape; }	void SetNSegments(Int_t s);
	void SetShape(TGeoShape* s);	void SetShape(TGeoShape* s);


		virtual void ComputeBBox();
	virtual void Paint(Option_t* option="");	virtual void Paint(Option_t* option="");

	void Save(const char* file, const char* name="Extract");	void Save(const char* file, const char* name="Extract");
	void SaveExtract(const char* file, const char* name);	void SaveExtract(const char* file, const char* name);
	void WriteExtract(const char* name);	void WriteExtract(const char* name);

	static TEveGeoShape* ImportShapeExtract(TEveGeoShapeExtract* gse, TEveEl ement* parent=0);	static TEveGeoShape* ImportShapeExtract(TEveGeoShapeExtract* gse, TEveEl ement* parent=0);

	// GeoProjectable	// GeoProjectable
	virtual TBuffer3D* MakeBuffer3D();	virtual TBuffer3D* MakeBuffer3D();
	virtual TClass* ProjectedClass(const TEveProjection* p) const;	virtual TClass* ProjectedClass(const TEveProjection* p) const;

	static TGeoManager* GetGeoMangeur();	static TGeoManager* GetGeoMangeur();


	ClassDef(TEveGeoShape, 1); // Wrapper for TGeoShape with absolute positi oning and color attributes allowing display of extracted TGeoShape's (witho ut an active TGeoManager) and simplified geometries (needed for NLT project ions).	ClassDef(TEveGeoShape, 2); // Wrapper for TGeoShape with absolute positi oning and color attributes allowing display of extracted TGeoShape's (witho ut an active TGeoManager) and simplified geometries (needed for NLT project ions).
	};	};

	//------------------------------------------------------------------------- -----	//------------------------------------------------------------------------- -----


	class TEveGeoShapeProjected : public TEveElementList,	class TEveGeoShapeProjected : public TEveShape,
	public TEveProjected,	public TEveProjected
	public TAttBBox
	{	{
	private:	private:
	TEveGeoShapeProjected(const TEveGeoShapeProjected&); // Not i mplemented	TEveGeoShapeProjected(const TEveGeoShapeProjected&); // Not i mplemented
	TEveGeoShapeProjected& operator=(const TEveGeoShapeProjected&); // Not i mplemented	TEveGeoShapeProjected& operator=(const TEveGeoShapeProjected&); // Not i mplemented

	protected:	protected:

	TBuffer3D* fBuff;	TBuffer3D *fBuff;

	virtual void SetDepthLocal(Float_t d);	virtual void SetDepthLocal(Float_t d);

	public:	public:
	TEveGeoShapeProjected();	TEveGeoShapeProjected();
	virtual ~TEveGeoShapeProjected() {}	virtual ~TEveGeoShapeProjected() {}


	virtual Bool_t CanEditMainTransparency() const { return kTRUE; }

	virtual void SetProjection(TEveProjectionManager* proj, TEveProjectable* model);	virtual void SetProjection(TEveProjectionManager* proj, TEveProjectable* model);
	virtual void UpdateProjection();	virtual void UpdateProjection();
	virtual TEveElement* GetProjectedAsElement() { return this; }	virtual TEveElement* GetProjectedAsElement() { return this; }

	virtual void ComputeBBox();	virtual void ComputeBBox();

	virtual void Paint(Option_t* option = "");

	ClassDef(TEveGeoShapeProjected, 0);	ClassDef(TEveGeoShapeProjected, 0);
	};	};

	#endif	#endif

End of changes. 16 change blocks.
	23 lines changed or deleted	19 lines changed or added

	TEvePolygonSetProjectedGL.h	TEvePolygonSetProjectedGL.h

	// @(#)root/eve:$Id: TEvePolygonSetProjectedGL.h 33124 2010-04-21 20:04:42Z matevz $	// @(#)root/eve:$Id: TEvePolygonSetProjectedGL.h 36853 2010-11-22 19:48:34Z matevz $
	// 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. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TEvePolygonSetProjectedGL	#ifndef ROOT_TEvePolygonSetProjectedGL
	#define ROOT_TEvePolygonSetProjectedGL	#define ROOT_TEvePolygonSetProjectedGL

	#include "TGLObject.h"	#include "TGLObject.h"


		class TEvePolygonSetProjected;

	class TEvePolygonSetProjectedGL : public TGLObject	class TEvePolygonSetProjectedGL : public TGLObject
	{	{

		protected:
		struct Edge_t
		{
		Int_t fI, fJ;
		Edge_t(Int_t i, Int_t j)
		{
		if (i <= j) { fI = i; fJ = j; }
		else { fI = j; fJ = i; }
		}

		bool operator<(const Edge_t& e) const
		{
		if (fI == e.fI)
		return fJ < e.fJ;
		else
		return fI < e.fI;
		}
		};

		TEvePolygonSetProjected *fM;

	public:	public:
	TEvePolygonSetProjectedGL();	TEvePolygonSetProjectedGL();
	virtual ~TEvePolygonSetProjectedGL() {}	virtual ~TEvePolygonSetProjectedGL() {}

	virtual Bool_t SetModel(TObject* obj, const Option_t* opt=0);	virtual Bool_t SetModel(TObject* obj, const Option_t* opt=0);
	virtual void SetBBox();	virtual void SetBBox();
	virtual void Draw(TGLRnrCtx& rnrCtx) const;	virtual void Draw(TGLRnrCtx& rnrCtx) const;
	virtual void DirectDraw(TGLRnrCtx& rnrCtx) const;	virtual void DirectDraw(TGLRnrCtx& rnrCtx) const;

	virtual void DrawHighlight(TGLRnrCtx& rnrCtx, const TGLPhysicalShape* pshp, Int_t lvl=-1) const;	virtual void DrawHighlight(TGLRnrCtx& rnrCtx, const TGLPhysicalShape* pshp, Int_t lvl=-1) const;

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

	TEveQuadSet.h	TEveQuadSet.h

	// @(#)root/eve:$Id: TEveQuadSet.h 33864 2010-06-14 09:47:19Z matevz $	// @(#)root/eve:$Id: TEveQuadSet.h 37234 2010-12-03 18:20:15Z matevz $
	// 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 27	skipping to change at line 27
	class TRandom;	class TRandom;

	class TEveQuadSet : public TEveDigitSet	class TEveQuadSet : public TEveDigitSet
	{	{
	friend class TEveQuadSetGL;	friend class TEveQuadSetGL;

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

	public:	public:

	enum EQuadType_e	enum EQuadType_e {
	{	kQT_Undef, // unknown-ignored
	kQT_Undef, // unknown-ignored	kQT_FreeQuad, // arbitrary quad: specify 4*(x,y,z) quad c
	kQT_FreeQuad, // arbitrary quad: specify 4*(x,y,z) qua	orners
	d corners	kQT_RectangleXY, // rectangle in x-y plane: specify x, y, z,
	kQT_RectangleXY, // rectangle in x-y plane: specify x, y,	w, h
	z, w, h	kQT_RectangleXZ, // rectangle in x-z plane: specify x, y, z,
	kQT_RectangleXZ, // rectangle in x-z plane: specify x, y,	w, h
	z, w, h	kQT_RectangleYZ, // rectangle in y-z plane: specify x, y, z,
	kQT_RectangleYZ, // rectangle in y-z plane: specify x, y,	w, h
	z, w, h	kQT_RectangleXYFixedDim, // rectangle in x-y plane: specify x, y, z;
	kQT_RectangleXYFixedDim, // rectangle in x-y plane: specify x, y,	w, h taken from fDefWidth/Height
	z; w, h taken from fDefWidth/Height	kQT_RectangleXYFixedZ, // rectangle in x-y plane: specify x, y, w,
	kQT_RectangleXYFixedZ, // rectangle in x-y plane: specify x, y,	h; z taken from fDefCoord
	w, h; z taken from fDefCoord	kQT_RectangleXZFixedY, // rectangle in x-z plane: specify x, z, w,
	kQT_RectangleXZFixedY, // rectangle in x-z plane: specify x, z,	h; y taken from fDefCoord
	w, h; y taken from fDefCoord	kQT_RectangleYZFixedX, // rectangle in y-z plane: specify y, z, w,
	kQT_RectangleYZFixedX, // rectangle in y-z plane: specify y, z,	h; x taken from fDefWidth/Height/Coord
	w, h; x taken from fDefWidth/Height/Coord	kQT_RectangleXYFixedDimZ, // rectangle in x-y plane: specify x, y; w,
	kQT_RectangleXYFixedDimZ, // rectangle in x-y plane: specify x, y;	h, z taken from fDefWidth/Height/Coord
	w, h, z taken from fDefWidth/Height/Coord	kQT_RectangleXZFixedDimY, // rectangle in x-z plane: specify x, z; w,
	kQT_RectangleXZFixedDimY, // rectangle in x-z plane: specify x, z;	h, y taken from fDefWidth/Height/Coord
	w, h, y taken from fDefWidth/Height/Coord	kQT_RectangleYZFixedDimX, // rectangle in y-z plane: specify y, z; w,
	kQT_RectangleYZFixedDimX, // rectangle in y-z plane: specify y, z;	h, x taken from fDefWidth/Height/Coord
	w, h, x taken from fDefWidth/Height/Coord	kQT_Rectangle_End,
	kQT_Rectangle_End,	// line modes (needed for uniform handling of silicon-strip digits)
	// line modes (needed for uniform handling of silicon-strip digits	kQT_LineXYFixedZ, // line in x-y plane: specify x, y, w(dx),
	)	h(dy); z taken from fDefCoord
	kQT_LineXYFixedZ, // line in x-y plane: specify x, y, w(dx	kQT_LineXZFixedY, // line in x-z plane: specify x, z, w(dx),
	), h(dy); z taken from fDefCoord	h(dz); y taken from fDefCoord
	kQT_LineXZFixedY, // line in x-z plane: specify x, z, w(dx	kQT_Line_End,
	), h(dz); y taken from fDefCoord	// hexagon modes
	kQT_Line_End,	kQT_HexagonXY, // horizontal hexagon: specify x, y, z, r
	// hexagon modes	kQT_HexagonYX, // vertical hexagon: specify x, y, z, r
	kQT_HexagonXY, // horizontal hexagon: specify x, y, z,	kQT_Hexagon_End
	r	// circle modes:
	kQT_HexagonYX, // vertical hexagon: specify x, y, z,	// QT_CircleXY, // specify r, z
	r	// QT_CircleXYFixedZ, // specify r
	kQT_Hexagon_End	// QT_CircleXYFixedR, // specify z
	// circle modes:	};
	// QT_CircleXY, // specify r, z
	// QT_CircleXYFixedZ, // specify r
	// QT_CircleXYFixedR, // specify z
	};

	protected:

	struct QFreeQuad_t : public DigitBase_t { Float_t fVertices[12]; };	struct QFreeQuad_t : public DigitBase_t { Float_t fVertices[12]; };

	struct QOrigin_t : public DigitBase_t { Float_t fA, fB; };	struct QOrigin_t : public DigitBase_t { Float_t fA, fB; };

	struct QRectFixDimC_t : public QOrigin_t {};	struct QRectFixDimC_t : public QOrigin_t {};

	struct QRectFixDim_t : public QRectFixDimC_t { Float_t fC; };	struct QRectFixDim_t : public QRectFixDimC_t { Float_t fC; };

	struct QRectFixC_t : public QRectFixDimC_t { Float_t fW, fH; };	struct QRectFixC_t : public QRectFixDimC_t { Float_t fW, fH; };

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

	TEveUtil.h	TEveUtil.h

	// @(#)root/eve:$Id: TEveUtil.h 33864 2010-06-14 09:47:19Z matevz $	// @(#)root/eve:$Id: TEveUtil.h 36373 2010-10-19 17:43:35Z matevz $
	// 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. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TEveUtil	#ifndef ROOT_TEveUtil
	#define ROOT_TEveUtil	#define ROOT_TEveUtil

	#include "TObject.h"	#include "TObject.h"
	#include "TString.h"	#include "TString.h"
	#include "TError.h"	#include "TError.h"

	#include "GuiTypes.h"	#include "GuiTypes.h"

	#include <list>	#include <list>

		#include <map>
	#include <set>	#include <set>
	#include <exception>	#include <exception>

	class TVirtualPad;	class TVirtualPad;
	class TGeoManager;	class TGeoManager;

	class TEveElement;	class TEveElement;

	/************************************************************************ **/	/************************************************************************ **/
	// TEveUtil	// TEveUtil

	skipping to change at line 184	skipping to change at line 185
	ClassDef(TEveRefCnt, 0); // Base-class for reference-counted objects.	ClassDef(TEveRefCnt, 0); // Base-class for reference-counted objects.
	};	};

	/************************************************************************ **/	/************************************************************************ **/
	// TEveRefBackPtr reference-count with back pointers	// TEveRefBackPtr reference-count with back pointers
	/************************************************************************ **/	/************************************************************************ **/

	class TEveRefBackPtr : public TEveRefCnt	class TEveRefBackPtr : public TEveRefCnt
	{	{
	protected:	protected:

	std::list<TEveElement*> fBackRefs;	typedef std::map<TEveElement*, Int_t> RefMap_t;
		typedef RefMap_t::iterator RefMap_i;

		RefMap_t fBackRefs;

	public:	public:
	TEveRefBackPtr();	TEveRefBackPtr();
	virtual ~TEveRefBackPtr();	virtual ~TEveRefBackPtr();

	TEveRefBackPtr(const TEveRefBackPtr&);	TEveRefBackPtr(const TEveRefBackPtr&);
	TEveRefBackPtr& operator=(const TEveRefBackPtr&);	TEveRefBackPtr& operator=(const TEveRefBackPtr&);

	using TEveRefCnt::IncRefCount;	using TEveRefCnt::IncRefCount;
	using TEveRefCnt::DecRefCount;	using TEveRefCnt::DecRefCount;

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

	TFileCollection.h	TFileCollection.h

	// @(#)root/base:$Id: TFileCollection.h 28573 2009-05-12 14:29:22Z rdm $	// @(#)root/base:$Id: TFileCollection.h 36629 2010-11-12 14:46:35Z brun $
	// Author: Jan Fiete Grosse-Oetringhaus 01/06/07	// Author: Jan Fiete Grosse-Oetringhaus 01/06/07

	/*************************************************************************	/*************************************************************************
	* 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 37	skipping to change at line 37
	#include "TNamed.h"	#include "TNamed.h"
	#endif	#endif

	#ifndef ROOT_TString	#ifndef ROOT_TString
	#include "TString.h"	#include "TString.h"
	#endif	#endif

	class THashList;	class THashList;
	class TMap;	class TMap;
	class TList;	class TList;

		class TCollection;
	class TFileInfo;	class TFileInfo;
	class TFileInfoMeta;	class TFileInfoMeta;
	class TObjString;	class TObjString;

	class TFileCollection : public TNamed {	class TFileCollection : public TNamed {

	private:	private:
	THashList *fList; //-> list of TFileInfos	THashList *fList; //-> list of TFileInfos
	TList *fMetaDataList; //-> generic list of file meta data obj ect(s)	TList *fMetaDataList; //-> generic list of file meta data obj ect(s)
	// (summed over entries of fList)	// (summed over entries of fList)

	skipping to change at line 74	skipping to change at line 75

	Int_t Add(TFileInfo *info);	Int_t Add(TFileInfo *info);
	Int_t Add(TFileCollection *coll);	Int_t Add(TFileCollection *coll);
	Int_t AddFromFile(const char *file, Int_t nfiles = -1, Int_t f irstfile = 1);	Int_t AddFromFile(const char *file, Int_t nfiles = -1, Int_t f irstfile = 1);
	Int_t Add(const char *path);	Int_t Add(const char *path);
	THashList *GetList() { return fList; }	THashList *GetList() { return fList; }
	void SetList(THashList* list) { fList = list; }	void SetList(THashList* list) { fList = list; }

	TObjString ExportInfo(const char name = 0, Int_t popt = 0);	TObjString ExportInfo(const char name = 0, Int_t popt = 0);


		Long64_t Merge(TCollection* list);
	Int_t RemoveDuplicates();	Int_t RemoveDuplicates();
	Int_t Update(Long64_t avgsize = -1);	Int_t Update(Long64_t avgsize = -1);
	void Sort();	void Sort();
	void SetAnchor(const char *anchor);	void SetAnchor(const char *anchor);
	void Print(Option_t *option = "") const;	void Print(Option_t *option = "") const;

	void SetBitAll(UInt_t f);	void SetBitAll(UInt_t f);
	void ResetBitAll(UInt_t f);	void ResetBitAll(UInt_t f);

	Long64_t GetTotalSize() const { return fTotalSize; }	Long64_t GetTotalSize() const { return fTotalSize; }

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

	TGFSContainer.h	TGFSContainer.h

	// @(#)root/gui:$Id: TGFSContainer.h 34072 2010-06-23 07:51:58Z bellenot $	// @(#)root/gui:$Id: TGFSContainer.h 36090 2010-10-05 17:32:34Z rdm $
	// Author: Fons Rademakers 19/01/98	// Author: Fons Rademakers 19/01/98

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, 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 52	skipping to change at line 52
	};	};

	class TRegexp;	class TRegexp;
	class TGPicture;	class TGPicture;
	class TGFileContainer;	class TGFileContainer;
	class TViewUpdateTimer;	class TViewUpdateTimer;
	class TGFileIcon;	class TGFileIcon;
	class TGFileItem;	class TGFileItem;
	class TTimer;	class TTimer;
	class TString;	class TString;

		struct FileStat_t;

	class TGFileItem : public TGLVEntry {	class TGFileItem : public TGLVEntry {

	protected:	protected:
	const TGPicture *fBlpic; // big icon	const TGPicture *fBlpic; // big icon
	const TGPicture *fSlpic; // small icon	const TGPicture *fSlpic; // small icon
	const TGPicture *fLcurrent; // current icon	const TGPicture *fLcurrent; // current icon
	Int_t fType; // file type	Int_t fType; // file type
	Int_t fUid, fGid; // file uid and gid	Int_t fUid, fGid; // file uid and gid
	Bool_t fIsLink; // true if symbolic link	Bool_t fIsLink; // true if symbolic link
	Long_t fModTime; // modification time	Long_t fModTime; // modification time
	Long64_t fSize; // file size	Long64_t fSize; // file size
	TBufferFile *fBuf; // buffer used for Drag and Drop	TBufferFile *fBuf; // buffer used for Drag and Drop
	TDNDData fDNDData; // Drag and Drop data	TDNDData fDNDData; // Drag and Drop data


		void Init(const TGPicture blpic, const TGPicture slpic,
		FileStat_t &stat, EListViewMode viewMode);
	virtual void DoRedraw();	virtual void DoRedraw();

	public:	public:
	TGFileItem(const TGWindow *p = 0,	TGFileItem(const TGWindow *p = 0,
	const TGPicture bpic = 0, const TGPicture blpic = 0,	const TGPicture bpic = 0, const TGPicture blpic = 0,
	const TGPicture spic = 0, const TGPicture slpic = 0,	const TGPicture spic = 0, const TGPicture slpic = 0,
	TGString *name = 0, Int_t type = 0, Long64_t size = 1,	TGString *name = 0, Int_t type = 0, Long64_t size = 1,
	Int_t uid = 0, Int_t gid = 0, Long_t modtime = 0,	Int_t uid = 0, Int_t gid = 0, Long_t modtime = 0,
	EListViewMode viewMode = kLVList, UInt_t options = kVerticalF rame,	EListViewMode viewMode = kLVList, UInt_t options = kVerticalF rame,
	Pixel_t back = GetWhitePixel());	Pixel_t back = GetWhitePixel());


		TGFileItem(const TGWindow *p,
		const TGPicture bpic, const TGPicture blpic,
		const TGPicture spic, const TGPicture slpic,
		TGString *name, FileStat_t &stat,
		EListViewMode viewMode = kLVList, UInt_t options = kVerticalF
		rame,
		Pixel_t back = GetWhitePixel());

	virtual ~TGFileItem();	virtual ~TGFileItem();

	virtual void SetViewMode(EListViewMode viewMode);	virtual void SetViewMode(EListViewMode viewMode);

	Bool_t IsActive() const { return fActive; }	Bool_t IsActive() const { return fActive; }
	Bool_t IsSymLink() const { return fIsLink; }	Bool_t IsSymLink() const { return fIsLink; }
	Int_t GetType() const { return fType; }	Int_t GetType() const { return fType; }
	Long64_t GetSize() const { return fSize; }	Long64_t GetSize() const { return fSize; }
	Long_t GetModTime() const { return fModTime; }	Long_t GetModTime() const { return fModTime; }
	Int_t GetUid() const { return fUid; }	Int_t GetUid() const { return fUid; }

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

	TGFont.h	TGFont.h

	// @(#)root/gui:$Id: TGFont.h 23115 2008-04-10 13:35:37Z rdm $	// @(#)root/gui:$Id: TGFont.h 35912 2010-09-30 13:43:06Z couet $
	// Author: Fons Rademakers 20/5/2003	// Author: Fons Rademakers 20/5/2003

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2003, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2003, 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 174	skipping to change at line 174
	Int_t fWidths[256]; // Array giving widths of all possibl e characters in the font.	Int_t fWidths[256]; // Array giving widths of all possibl e characters in the font.
	Int_t fBarHeight; // Height of underline or overstrike bar	Int_t fBarHeight; // Height of underline or overstrike bar
	// (used for simulating a native unde rlined or strikeout font).	// (used for simulating a native unde rlined or strikeout font).

	protected:	protected:
	TGFont(const char *name)	TGFont(const char *name)
	: TNamed(name,""), TRefCnt(), fFontStruct(0), fFontH(0), fFM(),	: TNamed(name,""), TRefCnt(), fFontStruct(0), fFontH(0), fFM(),
	fFA(), fNamedHash(0), fTabWidth(0), fUnderlinePos(0), fUnderlineHeight (0), fBarHeight(0)	fFA(), fNamedHash(0), fTabWidth(0), fUnderlinePos(0), fUnderlineHeight (0), fBarHeight(0)
	{	{
	SetRefCount(1);	SetRefCount(1);

		for (Int_t i=0; i<256; i++) {
		fWidths[i] = 0;
		fTypes[i] = ' ';
		}
	}	}

	TGFont(const TGFont &font); // not implemented	TGFont(const TGFont &font); // not implemented
	void operator=(const TGFont &font); // not implemented	void operator=(const TGFont &font); // not implemented

	LayoutChunk_t NewChunk(TGTextLayout layout, int *maxPtr,	LayoutChunk_t NewChunk(TGTextLayout layout, int *maxPtr,
	const char *start, int numChars,	const char *start, int numChars,
	int curX, int newX, int y) const;	int curX, int newX, int y) const;
	public:	public:
	virtual ~TGFont();	virtual ~TGFont();

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

	TGLAnnotation.h	TGLAnnotation.h

	// @(#)root/gl:$Id: TGLAnnotation.h 32600 2010-03-12 19:36:45Z matevz $	// @(#)root/gl:$Id: TGLAnnotation.h 36946 2010-11-25 15:29:03Z matevz $
	// Author: Matevz and Alja Tadel 20/02/2009	// Author: Matevz and Alja Tadel 20/02/2009

	/*************************************************************************	/*************************************************************************
	* 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 78	skipping to change at line 78

	Bool_t fDrawRefLine; // draw 3D refrence line	Bool_t fDrawRefLine; // draw 3D refrence line
	Bool_t fUseColorSet; // use color set from rnrCtx	Bool_t fUseColorSet; // use color set from rnrCtx
	Bool_t fAllowClose; // allow closing via 'X' button	Bool_t fAllowClose; // allow closing via 'X' button

	public:	public:
	TGLAnnotation(TGLViewerBase parent, const char text, Float_t posx, Flo at_t posy);	TGLAnnotation(TGLViewerBase parent, const char text, Float_t posx, Flo at_t posy);
	TGLAnnotation(TGLViewerBase parent, const char text, Float_t posx, Flo at_t posy, TGLVector3 ref);	TGLAnnotation(TGLViewerBase parent, const char text, Float_t posx, Flo at_t posy, TGLVector3 ref);
	virtual ~TGLAnnotation();	virtual ~TGLAnnotation();


	void SetTransparency(Char_t x) { fTransparency = x; }	void SetText(const TString& x) { fText = x; }
	Char_t GetTransparency() const { return fTransparency; }	const TString& GetText() const { return fText; }
	void SetUseColorSet(Bool_t x) { fUseColorSet = x; }
	Bool_t GetUseColorSet() const { return fUseColorSet; }	void SetTransparency(Char_t x) { fTransparency = x; }
	void SetBackColor(Color_t x) { fBackColor = x; }	Char_t GetTransparency() const { return fTransparency; }
	Color_t GetBackColor() const { return fBackColor; }
	void SetTextColor(Color_t x) { fTextColor = x; }	void SetUseColorSet(Bool_t x) { fUseColorSet = x; }
	Color_t GetTextColor() const { return fTextColor; }	Bool_t GetUseColorSet() const { return fUseColorSet; }
	void SetTextSize(Float_t x) { fTextSize = x; }
	Float_t GetTextSize() const { return fTextSize; }	void SetBackColor(Color_t x) { fBackColor = x; }
	void SetAllowClose(Bool_t x) { fAllowClose = x; }	Color_t GetBackColor() const { return fBackColor; }
	Bool_t GetAllowClose() const { return fAllowClose;}
		void SetTextColor(Color_t x) { fTextColor = x; }
		Color_t GetTextColor() const { return fTextColor; }

		void SetTextSize(Float_t x) { fTextSize = x; }
		Float_t GetTextSize() const { return fTextSize; }

		void SetAllowClose(Bool_t x) { fAllowClose = x; }
		Bool_t GetAllowClose() const { return fAllowClose; }

	TGLFont::ETextAlignH_e GetTextAlign() const { return fTextAlign; }	TGLFont::ETextAlignH_e GetTextAlign() const { return fTextAlign; }
	void SetTextAlign(TGLFont::ETextAlignH_e a) { fTextAlign = a; }	void SetTextAlign(TGLFont::ETextAlignH_e a) { fTextAlign = a; }

	virtual Bool_t MouseEnter(TGLOvlSelectRecord& selRec);	virtual Bool_t MouseEnter(TGLOvlSelectRecord& selRec);
	virtual Bool_t Handle(TGLRnrCtx& rnrCtx, TGLOvlSelectRecord& selRec,	virtual Bool_t Handle(TGLRnrCtx& rnrCtx, TGLOvlSelectRecord& selRec,
	Event_t* event);	Event_t* event);
	virtual void MouseLeave();	virtual void MouseLeave();

	void CloseEditor();	void CloseEditor();


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

	TGLContext.h	TGLContext.h

	// @(#)root/gl:$Id: TGLContext.h 29332 2009-07-03 17:02:46Z matevz $	// @(#)root/gl:$Id: TGLContext.h 36675 2010-11-15 20:33:58Z matevz $
	#include <utility>	#include <utility>
	#include <list>	#include <list>

	/*************************************************************************	/*************************************************************************
	* 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 47	skipping to change at line 47
	private:	private:
	TGLPaintDevice *fDevice;	TGLPaintDevice *fDevice;
	TGLContextPrivate *fPimpl;	TGLContextPrivate *fPimpl;

	Bool_t fFromCtor;//To prohibit user's calls of SetContext.	Bool_t fFromCtor;//To prohibit user's calls of SetContext.
	Bool_t fValid;	Bool_t fValid;

	TGLContextIdentity *fIdentity;	TGLContextIdentity *fIdentity;

	static Bool_t fgGlewInitDone;	static Bool_t fgGlewInitDone;

	void GlewInit();

	public:	public:
	TGLContext(TGLWidget glWidget, Bool_t shareDefault=kTRUE, const TGLCont ext shareList=0);	TGLContext(TGLWidget glWidget, Bool_t shareDefault=kTRUE, const TGLCont ext shareList=0);
	// TGLContext(TGLPBuffer glPbuf, const TGLContext shareList = 0);	// TGLContext(TGLPBuffer glPbuf, const TGLContext shareList = 0);

	TGLContextIdentity *GetIdentity()const;	TGLContextIdentity *GetIdentity()const;

	virtual ~TGLContext();	virtual ~TGLContext();

	Bool_t MakeCurrent();	Bool_t MakeCurrent();

	skipping to change at line 70	skipping to change at line 69

	//This functions are public _ONLY_ for calls via	//This functions are public _ONLY_ for calls via
	//gROOT under win32. Please, DO NOT CALL IT DIRECTLY.	//gROOT under win32. Please, DO NOT CALL IT DIRECTLY.
	void SetContext(TGLWidget widget, const TGLContext shareLi st);	void SetContext(TGLWidget widget, const TGLContext shareLi st);
	// void SetContextPB(TGLPBuffer pbuff, const TGLContext share List);	// void SetContextPB(TGLPBuffer pbuff, const TGLContext share List);
	void Release();	void Release();

	Bool_t IsValid() const { return fValid; }	Bool_t IsValid() const { return fValid; }

	static TGLContext *GetCurrent();	static TGLContext *GetCurrent();

		static void GlewInit();

	private:	private:
	TGLContext(const TGLContext &);	TGLContext(const TGLContext &);
	TGLContext &operator = (const TGLContext &);	TGLContext &operator = (const TGLContext &);

	ClassDef(TGLContext, 0); // Control internal gl-context resources.	ClassDef(TGLContext, 0); // Control internal gl-context resources.
	};	};

	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____


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

	TGLFBO.h	TGLFBO.h

	// @(#)root/gl:$Id: TGLFBO.h 33579 2010-05-19 12:43:08Z rdm $	// @(#)root/gl:$Id: TGLFBO.h 36675 2010-11-15 20:33:58Z matevz $
	/*************************************************************************	/*************************************************************************
	* 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. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TGLFBO	#ifndef ROOT_TGLFBO
	#define ROOT_TGLFBO	#define ROOT_TGLFBO

	skipping to change at line 25	skipping to change at line 25
	class TGLFBO	class TGLFBO
	{	{
	private:	private:
	TGLFBO(const TGLFBO&); // Not implemented	TGLFBO(const TGLFBO&); // Not implemented
	TGLFBO& operator=(const TGLFBO&); // Not implemented	TGLFBO& operator=(const TGLFBO&); // Not implemented

	protected:	protected:
	UInt_t fFrameBuffer;	UInt_t fFrameBuffer;
	UInt_t fColorTexture;	UInt_t fColorTexture;
	UInt_t fDepthBuffer;	UInt_t fDepthBuffer;

	// UInt_t fStencilBuffer;	UInt_t fMSFrameBuffer;
		UInt_t fMSColorBuffer;


	Int_t fW, fH;	Int_t fW, fH, fMSSamples, fMSCoverageSamples;


	Bool_t fIsRescaled;
	Float_t fWScale, fHScale;	Float_t fWScale, fHScale;

		Bool_t fIsRescaled;

	static Bool_t fgRescaleToPow2;	static Bool_t fgRescaleToPow2;

		static Bool_t fgMultiSampleNAWarned;

		void InitStandard();
		void InitMultiSample();

		UInt_t CreateAndAttachRenderBuffer(Int_t format, Int_t type);
		UInt_t CreateAndAttachColorTexture();

	public:	public:
	TGLFBO();	TGLFBO();
	virtual ~TGLFBO();	virtual ~TGLFBO();


	void Init(int w, int h);	void Init(int w, int h, int ms_samples=0);
	void Release();	void Release();

	void Bind();	void Bind();
	void Unbind();	void Unbind();

	void BindTexture();	void BindTexture();
	void UnbindTexture();	void UnbindTexture();


		void SetAsReadBuffer();

	ClassDef(TGLFBO, 0); // Frame-buffer object.	ClassDef(TGLFBO, 0); // Frame-buffer object.
	};	};

	#endif	#endif

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

	TGLFormat.h	TGLFormat.h

	// @(#)root/gl:$Id: TGLFormat.h 31821 2009-12-10 18:22:44Z matevz $	// @(#)root/gl:$Id: TGLFormat.h 36675 2010-11-15 20:33:58Z matevz $
	/*************************************************************************	/*************************************************************************
	* 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. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TGLFormat	#ifndef ROOT_TGLFormat
	#define ROOT_TGLFormat	#define ROOT_TGLFormat


	#ifndef ROOT_Rtypes
	#include "Rtypes.h"	#include "Rtypes.h"

	#endif
		#include <vector>

	/*	/*
	TGLFormat class describes the pixel format of a drawing surface.	TGLFormat class describes the pixel format of a drawing surface.
	It's a generic analog of PIXELFORMATDESCRIPTOR (win32) or	It's a generic analog of PIXELFORMATDESCRIPTOR (win32) or
	array of integer constants array for glXChooseVisual (X11).	array of integer constants array for glXChooseVisual (X11).
	This class is in a very preliminary state, different	This class is in a very preliminary state, different
	options have not been tested yet, only defaults.	options have not been tested yet, only defaults.

	Surface can be:	Surface can be:
	-RGBA	-RGBA
	-with/without depth buffer	-with/without depth buffer
	-with/without stencil buffer	-with/without stencil buffer
	-with/without accum buffer	-with/without accum buffer
	-double/single buffered	-double/single buffered
	*/	*/


	class TGLFormat {	class TGLFormat
		{
	public:	public:

	enum EFormatOptions {	enum EFormatOptions
		{
		kNone = 0,
	kDoubleBuffer = 1,	kDoubleBuffer = 1,
	kDepth = 2,	kDepth = 2,
	kAccum = 4,	kAccum = 4,
	kStencil = 8,	kStencil = 8,

	kStereo = 16	kStereo = 16,
		kMultiSample = 32
	};	};

	private:	private:
	Bool_t fDoubleBuffered;	Bool_t fDoubleBuffered;
	Bool_t fStereo;	Bool_t fStereo;

	UInt_t fDepthSize;	Int_t fDepthSize;
	UInt_t fAccumSize;	Int_t fAccumSize;
	UInt_t fStencilSize;	Int_t fStencilSize;
		Int_t fSamples;

		static std::vector<Int_t> fgAvailableSamples;

		static Int_t GetDefaultSamples();
		static void InitAvailableSamples();

	public:	public:
	TGLFormat();	TGLFormat();
	TGLFormat(EFormatOptions options);	TGLFormat(EFormatOptions options);

	//Virtual dtor only to supress warnings from g++ -	//Virtual dtor only to supress warnings from g++ -
	//ClassDef adds virtual functions, so g++ wants virtual dtor.	//ClassDef adds virtual functions, so g++ wants virtual dtor.
	virtual ~TGLFormat();	virtual ~TGLFormat();

	Bool_t operator == (const TGLFormat &rhs)const;	Bool_t operator == (const TGLFormat &rhs)const;
	Bool_t operator != (const TGLFormat &rhs)const;	Bool_t operator != (const TGLFormat &rhs)const;


	UInt_t GetDepthSize()const;	Int_t GetDepthSize()const;
	void SetDepthSize(UInt_t depth);	void SetDepthSize(Int_t depth);
	Bool_t HasDepth()const;	Bool_t HasDepth()const;


	UInt_t GetStencilSize()const;	Int_t GetStencilSize()const;
	void SetStencilSize(UInt_t stencil);	void SetStencilSize(Int_t stencil);
	Bool_t HasStencil()const;	Bool_t HasStencil()const;


	UInt_t GetAccumSize()const;	Int_t GetAccumSize()const;
	void SetAccumSize(UInt_t accum);	void SetAccumSize(Int_t accum);
	Bool_t HasAccumBuffer()const;	Bool_t HasAccumBuffer()const;

	Bool_t IsDoubleBuffered()const;	Bool_t IsDoubleBuffered()const;
	void SetDoubleBuffered(Bool_t db);	void SetDoubleBuffered(Bool_t db);

	Bool_t IsStereo()const;	Bool_t IsStereo()const;
	void SetStereo(Bool_t db);	void SetStereo(Bool_t db);


	ClassDef(TGLFormat, 0) // Describes GL buffer format.	Int_t GetSamples()const;
		void SetSamples(Int_t samples);
		Bool_t HasMultiSampling()const;

		ClassDef(TGLFormat, 0); // Describes GL buffer format.
	};	};

	#endif	#endif

End of changes. 11 change blocks.
	16 lines changed or deleted	30 lines changed or added

	TGLObject.h	TGLObject.h

	// @(#)root/gl:$Id: TGLObject.h 33124 2010-04-21 20:04:42Z matevz $	// @(#)root/gl:$Id: TGLObject.h 36384 2010-10-20 14:26:41Z matevz $
	// Author: Matevz Tadel 7/4/2006	// Author: Matevz Tadel 7/4/2006

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2006, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2006, 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_TGLObject	#ifndef ROOT_TGLObject
	#define ROOT_TGLObject	#define ROOT_TGLObject

	#include "TGLLogicalShape.h"	#include "TGLLogicalShape.h"
	#include "TMap.h"	#include "TMap.h"

		#include <stdexcept>

	class TClass;	class TClass;

	class TGLObject : public TGLLogicalShape	class TGLObject : public TGLLogicalShape
	{	{
	private:	private:
	static TMap fgGLClassMap;	static TMap fgGLClassMap;
	static TClass* SearchGLRenderer(TClass* cls);	static TClass* SearchGLRenderer(TClass* cls);

	protected:	protected:
	mutable Bool_t fMultiColor; // Are multiple colors used for object rende ring.	mutable Bool_t fMultiColor; // Are multiple colors used for object rende ring.

	Bool_t SetModelCheckClass(TObject* obj, TClass* cls);	Bool_t SetModelCheckClass(TObject* obj, TClass* cls);

	void SetAxisAlignedBBox(Float_t xmin, Float_t xmax,	void SetAxisAlignedBBox(Float_t xmin, Float_t xmax,
	Float_t ymin, Float_t ymax,	Float_t ymin, Float_t ymax,
	Float_t zmin, Float_t zmax);	Float_t zmin, Float_t zmax);
	void SetAxisAlignedBBox(const Float_t* p);	void SetAxisAlignedBBox(const Float_t* p);


		template <class TT> TT* SetModelDynCast(TObject* obj)
		{
		TT ret = dynamic_cast<TT>(obj);
		if (!ret) throw std::runtime_error("Object of wrong type passed.");
		fExternalObj = obj;
		return ret;
		}

		template <class TT> TT* DynCast(TObject* obj)
		{
		TT ret = dynamic_cast<TT>(obj);
		if (!ret) throw std::runtime_error("Object of wrong type passed.");
		return ret;
		}

	public:	public:
	TGLObject() : TGLLogicalShape(0), fMultiColor(kFALSE) {}	TGLObject() : TGLLogicalShape(0), fMultiColor(kFALSE) {}
	virtual ~TGLObject() {}	virtual ~TGLObject() {}

	virtual Bool_t ShouldDLCache(const TGLRnrCtx& rnrCtx) const;	virtual Bool_t ShouldDLCache(const TGLRnrCtx& rnrCtx) const;

	// Kept from TGLLogicalShape	// Kept from TGLLogicalShape
	// virtual ELODAxes SupportedLODAxes() const { return kLODAxesNone; }	// virtual ELODAxes SupportedLODAxes() const { return kLODAxesNone; }

	// Changed from TGLLogicalShape	// Changed from TGLLogicalShape

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

	TGLPadUtils.h	TGLPadUtils.h

	// @(#)root/gl:$Id: TGLPadUtils.h 33600 2010-05-21 09:24:32Z rdm $	// @(#)root/gl:$Id: TGLPadUtils.h 36532 2010-11-08 10:36:48Z couet $
	// Author: Timur Pocheptsov 06/05/2009	// Author: Timur Pocheptsov 06/05/2009

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2009, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2009, 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_TGLPadUtils	#ifndef ROOT_TGLPadUtils
	#define ROOT_TGLPadUtils	#define ROOT_TGLPadUtils

	#include <vector>	#include <vector>

		#include <list>

	#ifndef ROOT_RStipples	#ifndef ROOT_RStipples
	#include "RStipples.h"	#include "RStipples.h"
	#endif	#endif
	#ifndef ROOT_TPoint	#ifndef ROOT_TPoint
	#include "TPoint.h"	#include "TPoint.h"
	#endif	#endif
	#ifndef ROOT_Rtypes	#ifndef ROOT_Rtypes
	#include "Rtypes.h"	#include "Rtypes.h"
	#endif	#endif

	skipping to change at line 142	skipping to change at line 143
	void DrawFullSquare(UInt_t n, const TPoint *xy)const;	void DrawFullSquare(UInt_t n, const TPoint *xy)const;
	void DrawFullTrianlgeUp(UInt_t n, const TPoint *xy)const;	void DrawFullTrianlgeUp(UInt_t n, const TPoint *xy)const;
	void DrawFullTrianlgeDown(UInt_t n, const TPoint *xy)const;	void DrawFullTrianlgeDown(UInt_t n, const TPoint *xy)const;
	void DrawDiamond(UInt_t n, const TPoint *xy)const;	void DrawDiamond(UInt_t n, const TPoint *xy)const;
	void DrawCross(UInt_t n, const TPoint *xy)const;	void DrawCross(UInt_t n, const TPoint *xy)const;
	void DrawFullStar(UInt_t n, const TPoint *xy)const;	void DrawFullStar(UInt_t n, const TPoint *xy)const;
	void DrawOpenStar(UInt_t n, const TPoint *xy)const;	void DrawOpenStar(UInt_t n, const TPoint *xy)const;

	};	};


		//
		// OpenGL's tesselator calls callback functions glBegin(MODE), glVertex3(v)
		, glEnd(),
		// where v can be new vertex (or existing) and MODE is a type of mesh patch
		.
		// MeshPatch_t is a class to save such a tesselation
		// (instead of using glVertex and glBegin to draw.
		//
		struct MeshPatch_t {
		MeshPatch_t(Int_t type) : fPatchType(type)
		{}

		Int_t fPatchType; //GL_QUADS, GL_QUAD_STRIP, etc.
		std::vector<Double_t> fPatch; //vertices.
		};

		typedef std::list<MeshPatch_t> Tesselation_t;

	class Tesselator {	class Tesselator {


	public:	public:

	Tesselator();	Tesselator(Bool_t dump = kFALSE);

	~Tesselator();	~Tesselator();

	void *GetTess()const	void *GetTess()const
	{	{
	return fTess;	return fTess;
	}	}


		static void SetDump(Tesselation_t *t)
		{
		fVs = t;
		}

		static Tesselation_t *GetDump()
		{
		return fVs;
		}

	private:	private:


	void *fTess;	void *fTess;


		static Tesselation_t *fVs;//the current tesselator's dump.
	};	};

	/*	/*
	In future, this should be an interface to per-pad FBO.	In future, this should be an interface to per-pad FBO.
	Currently, in only save sizes and coordinates (?)	Currently, in only save sizes and coordinates (?)
	*/	*/
	class OffScreenDevice {	class OffScreenDevice {
	friend class ::TGLPadPainter;	friend class ::TGLPadPainter;
	public:	public:
	OffScreenDevice(UInt_t w, UInt_t h, UInt_t x, UInt_t y, Bool_t top);	OffScreenDevice(UInt_t w, UInt_t h, UInt_t x, UInt_t y, Bool_t top);

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

	TGLPlotBox.h	TGLPlotBox.h

	skipping to change at line 44	skipping to change at line 44
	const Bool_t fXOZSelectable;	const Bool_t fXOZSelectable;
	const Bool_t fYOZSelectable;	const Bool_t fYOZSelectable;

	Bool_t fSelectablePairs[4][2];	Bool_t fSelectablePairs[4][2];

	TGLVertex3 f3DBox[8];	TGLVertex3 f3DBox[8];
	mutable TGLVertex3 f2DBox[8];	mutable TGLVertex3 f2DBox[8];
	mutable TGLVertex3 f2DBoxU[8];	mutable TGLVertex3 f2DBoxU[8];
	mutable Int_t fFrontPoint;	mutable Int_t fFrontPoint;


		//The sizes of a "unit" cube.
		Double_t fRangeXU;
		Double_t fRangeYU;
		Double_t fRangeZU;

	public:	public:

	TGLPlotBox(Bool_t xoySelectable, Bool_t xozSelectable, Bool_t yozSelecta ble);	TGLPlotBox(Bool_t xoySelectable, Bool_t xozSelectable, Bool_t yozSelecta ble);
	//ClassDef macro adds some virtual functions,	//ClassDef macro adds some virtual functions,
	//so, to supress g++ warnings virtual destructor declared.	//so, to supress g++ warnings virtual destructor declared.
	virtual ~TGLPlotBox();	virtual ~TGLPlotBox();

	void DrawBox(Int_t selectedPart, Bool_t selectionPass,	void DrawBox(Int_t selectedPart, Bool_t selectionPass,
	const std::vector<Double_t> &zLevels,	const std::vector<Double_t> &zLevels,
	Bool_t highColor)const;	Bool_t highColor)const;

	void SetPlotBox(const Rgl::Range_t &xRange,	void SetPlotBox(const Rgl::Range_t &xRange,
	const Rgl::Range_t &yRange,	const Rgl::Range_t &yRange,
	const Rgl::Range_t &zRange);	const Rgl::Range_t &zRange);

		void SetPlotBox(const Rgl::Range_t &xRange, Double_t rangeXU,
		const Rgl::Range_t &yRange, Double_t rangeYU,
		const Rgl::Range_t &zRange, Double_t rangeZU);

	void SetFrameColor(const TColor *color);	void SetFrameColor(const TColor *color);

	Int_t FindFrontPoint()const;	Int_t FindFrontPoint()const;
	Int_t GetFrontPoint()const;	Int_t GetFrontPoint()const;

	const TGLVertex3 *Get3DBox()const;	const TGLVertex3 *Get3DBox()const;
	const TGLVertex3 *Get2DBox()const;	const TGLVertex3 *Get2DBox()const;

	static const Int_t fgFramePlanes[][4];	static const Int_t fgFramePlanes[][4];
	static const Int_t fgBackPairs[][2];	static const Int_t fgBackPairs[][2];

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

	TGLPlotPainter.h	TGLPlotPainter.h

	// @(#)root/gl:$Id: TGLPlotPainter.h 30298 2009-09-19 13:07:06Z matevz $	// @(#)root/gl:$Id: TGLPlotPainter.h 36773 2010-11-19 12:26:30Z couet $
	// Author: Timur Pocheptsov 14/06/2006	// Author: Timur Pocheptsov 14/06/2006

	/*************************************************************************	/*************************************************************************
	* 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 305	skipping to change at line 305
	void RestoreProjectionMatrix()const;	void RestoreProjectionMatrix()const;

	ClassDef(TGLPlotPainter, 0) //Base for gl plots	ClassDef(TGLPlotPainter, 0) //Base for gl plots
	};	};

	/*	/*
	Auxiliary class, which holds different	Auxiliary class, which holds different
	information about plot's current coordinate system	information about plot's current coordinate system
	*/	*/


		class TH2Poly;

	class TGLPlotCoordinates {	class TGLPlotCoordinates {
	private:	private:
	EGLCoordType fCoordType;	EGLCoordType fCoordType;

	Rgl::BinRange_t fXBins;	Rgl::BinRange_t fXBins;
	Rgl::BinRange_t fYBins;	Rgl::BinRange_t fYBins;
	Rgl::BinRange_t fZBins;	Rgl::BinRange_t fZBins;

	Double_t fXScale;	Double_t fXScale;
	Double_t fYScale;	Double_t fYScale;

	skipping to change at line 350	skipping to change at line 352
	Bool_t GetXLog()const;	Bool_t GetXLog()const;

	void SetYLog(Bool_t yLog);	void SetYLog(Bool_t yLog);
	Bool_t GetYLog()const;	Bool_t GetYLog()const;

	void SetZLog(Bool_t zLog);	void SetZLog(Bool_t zLog);
	Bool_t GetZLog()const;	Bool_t GetZLog()const;

	void ResetModified();	void ResetModified();
	Bool_t Modified()const;	Bool_t Modified()const;

		//
	Bool_t SetRanges(const TH1 *hist, Bool_t errors = kFALSE, Bool_t zBins = kFALSE);	Bool_t SetRanges(const TH1 *hist, Bool_t errors = kFALSE, Bool_t zBins = kFALSE);
	//	//

		Bool_t SetRanges(TH2Poly *hist);
		//
	Bool_t SetRanges(const TAxis xAxis, const TAxis yAxis, const TAxis *zA xis);	Bool_t SetRanges(const TAxis xAxis, const TAxis yAxis, const TAxis *zA xis);

	Int_t GetNXBins()const;	Int_t GetNXBins()const;
	Int_t GetNYBins()const;	Int_t GetNYBins()const;
	Int_t GetNZBins()const;	Int_t GetNZBins()const;

	const Rgl::BinRange_t &GetXBins()const;	const Rgl::BinRange_t &GetXBins()const;
	const Rgl::BinRange_t &GetYBins()const;	const Rgl::BinRange_t &GetYBins()const;
	const Rgl::BinRange_t &GetZBins()const;	const Rgl::BinRange_t &GetZBins()const;


	skipping to change at line 407	skipping to change at line 411
	ClassDef(TGLPlotCoordinates, 0)//Auxilary class, holds plot dimensions.	ClassDef(TGLPlotCoordinates, 0)//Auxilary class, holds plot dimensions.
	};	};

	class TGLLevelPalette;	class TGLLevelPalette;

	namespace Rgl {	namespace Rgl {

	void DrawPalette(const TGLPlotCamera * camera, const TGLLevelPalette & pale tte);	void DrawPalette(const TGLPlotCamera * camera, const TGLLevelPalette & pale tte);
	void DrawPaletteAxis(const TGLPlotCamera * camera, const Range_t & minMax, Bool_t logZ);	void DrawPaletteAxis(const TGLPlotCamera * camera, const Range_t & minMax, Bool_t logZ);


		//Polygonal histogram (TH2Poly) is slightly stretched along x and y.
		extern const Double_t gH2PolyScaleXY;

	}	}

	#endif	#endif

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

	TGLRnrCtx.h	TGLRnrCtx.h

	// @(#)root/gl:$Id: TGLRnrCtx.h 34006 2010-06-21 10:36:05Z matevz $	// @(#)root/gl:$Id: TGLRnrCtx.h 36675 2010-11-15 20:33:58Z matevz $
	/*************************************************************************	/*************************************************************************
	* 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. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TGLRnrCtx	#ifndef ROOT_TGLRnrCtx
	#define ROOT_TGLRnrCtx	#define ROOT_TGLRnrCtx

	skipping to change at line 259	skipping to change at line 259

	void RegisterFont(Int_t size, Int_t file, Int_t mode, TGLFont& out);	void RegisterFont(Int_t size, Int_t file, Int_t mode, TGLFont& out);
	void RegisterFont(Int_t size, const char* name, Int_t mode, TGLFont& ou t);	void RegisterFont(Int_t size, const char* name, Int_t mode, TGLFont& ou t);
	void RegisterFontNoScale(Int_t size, Int_t file, Int_t mode, TGLFont& o ut);	void RegisterFontNoScale(Int_t size, Int_t file, Int_t mode, TGLFont& o ut);
	void RegisterFontNoScale(Int_t size, const char* name, Int_t mode, TGLF ont& out);	void RegisterFontNoScale(Int_t size, const char* name, Int_t mode, TGLF ont& out);
	void ReleaseFont(TGLFont& font);	void ReleaseFont(TGLFont& font);

	GLUquadric* GetGluQuadric() { return fQuadric; }	GLUquadric* GetGluQuadric() { return fQuadric; }

	// Picture grabbing	// Picture grabbing

	void SetGrabImage(Bool_t gi, Int_t buf=-1) { fGrabImage = gi; fGrabB uffer = buf; }	void SetGrabImage(Bool_t gi) { fGrabImage = gi; }
	Bool_t GetGrabImage() const { return fGrabImage; }	Bool_t GetGrabImage() const { return fGrabImage; }

	Int_t GetGrabBuffer() const { return fGrabBuffer; }
	UChar_t* GetGrabbedImage() const { return fGrabbedImage; }
	void SetGrabbedImage(UChar_t* img) { fGrabbedImage = img; }

	// Matrix manipulation helpers	// Matrix manipulation helpers
	void ProjectionMatrixPushIdentity();	void ProjectionMatrixPushIdentity();
	void ProjectionMatrixPop();	void ProjectionMatrixPop();

	ClassDef(TGLRnrCtx, 0); // Collection of objects and data passes along a ll rendering calls.	ClassDef(TGLRnrCtx, 0); // Collection of objects and data passes along a ll rendering calls.
	};	};

	#endif	#endif

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

	TGLSAViewer.h	TGLSAViewer.h

	// @(#)root/gl:$Id: TGLSAViewer.h 32770 2010-03-25 17:05:08Z matevz $	// @(#)root/gl:$Id: TGLSAViewer.h 36895 2010-11-24 11:46:09Z matevz $
	// Author: Richard Maunder / Timur Pocheptsov	// Author: Richard Maunder / Timur Pocheptsov

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2005, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2005, 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 47	skipping to change at line 47
	{	{
	public:	public:
	enum EGLSACommands {	enum EGLSACommands {
	kGLHelpAbout, kGLHelpViewer,	kGLHelpAbout, kGLHelpViewer,
	kGLPerspYOZ, kGLPerspXOZ, kGLPerspXOY,	kGLPerspYOZ, kGLPerspXOZ, kGLPerspXOY,
	kGLXOY, kGLXOZ, kGLZOY,	kGLXOY, kGLXOZ, kGLZOY,
	kGLXnOY, kGLXnOZ, kGLZnOY,	kGLXnOY, kGLXnOZ, kGLZnOY,
	kGLOrthoRotate, kGLOrthoDolly,	kGLOrthoRotate, kGLOrthoDolly,
	kGLSaveEPS, kGLSavePDF, kGLSavePNG, kGLSaveGIF, kGLSaveAnimGIF,	kGLSaveEPS, kGLSavePDF, kGLSavePNG, kGLSaveGIF, kGLSaveAnimGIF,
	kGLSaveJPG, kGLSaveAS, kGLCloseViewer, kGLQuitROOT,	kGLSaveJPG, kGLSaveAS, kGLCloseViewer, kGLQuitROOT,

	kGLEditObject };	kGLEditObject, kGLHideMenus };

	private:	private:
	// GUI components	// GUI components
	TGLSAFrame *fFrame;	TGLSAFrame *fFrame;
	TGLFormat *fFormat;	TGLFormat *fFormat;
	TGPopupMenu *fFileMenu;	TGPopupMenu *fFileMenu;
	TGPopupMenu *fFileSaveMenu;	TGPopupMenu *fFileSaveMenu;
	TGPopupMenu *fCameraMenu;	TGPopupMenu *fCameraMenu;
	TGPopupMenu *fHelpMenu;	TGPopupMenu *fHelpMenu;


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

	TGLScenePad.h	TGLScenePad.h

	// @(#)root/gl:$Id: TGLScenePad.h 26649 2008-12-04 11:30:23Z matevz $	// @(#)root/gl:$Id: TGLScenePad.h 36884 2010-11-23 17:52:08Z matevz $
	/*************************************************************************	/*************************************************************************
	* 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. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TGLScenePad	#ifndef ROOT_TGLScenePad
	#define ROOT_TGLScenePad	#define ROOT_TGLScenePad

	skipping to change at line 55	skipping to change at line 55

	// Composite shape specific	// Composite shape specific
	typedef std::pair<UInt_t, RootCsg::TBaseMesh*> CSPart_t;	typedef std::pair<UInt_t, RootCsg::TBaseMesh*> CSPart_t;
	mutable TGLFaceSet *fComposite; //! Paritally created composite	mutable TGLFaceSet *fComposite; //! Paritally created composite
	UInt_t fCSLevel;	UInt_t fCSLevel;
	std::vector<CSPart_t> fCSTokens;	std::vector<CSPart_t> fCSTokens;
	RootCsg::TBaseMesh* BuildComposite();	RootCsg::TBaseMesh* BuildComposite();

	TGLLogicalShape* AttemptDirectRenderer(TObject* id);	TGLLogicalShape* AttemptDirectRenderer(TObject* id);


	Bool_t fSmartRefresh; //! cache logicals during scene rebuilds , use TAtt3D time-stamp to determine if they are still valid	Bool_t fSmartRefresh; //! cache logicals during scene rebuilds

	public:	public:
	TGLScenePad(TVirtualPad* pad);	TGLScenePad(TVirtualPad* pad);
	virtual ~TGLScenePad() {}	virtual ~TGLScenePad() {}

	TVirtualPad* GetPad() const { return fPad; }	TVirtualPad* GetPad() const { return fPad; }
	// void SetPad(TVirtualPad* p) { fPad = p; /* also need to drop contents */ }	// void SetPad(TVirtualPad* p) { fPad = p; /* also need to drop contents */ }

	// Histo import and Sub-pad traversal	// Histo import and Sub-pad traversal
	void AddHistoPhysical(TGLLogicalShape* log);	void AddHistoPhysical(TGLLogicalShape* log);

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

	TGLUtil.h	TGLUtil.h

	// @(#)root/gl:$Id: TGLUtil.h 34006 2010-06-21 10:36:05Z matevz $	// @(#)root/gl:$Id: TGLUtil.h 36624 2010-11-12 12:17:06Z couet $
	// Author: Richard Maunder 25/05/2005	// Author: Richard Maunder 25/05/2005

	/*************************************************************************	/*************************************************************************
	* 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 1177	skipping to change at line 1177
	return &std::vector<T>::operator [] (ind * fRowLen);	return &std::vector<T>::operator [] (ind * fRowLen);
	}	}
	};	};

	class TGLPlotCoordinates;	class TGLPlotCoordinates;
	class TGLQuadric;	class TGLQuadric;
	class TAxis;	class TAxis;

	namespace Rgl {	namespace Rgl {


	extern const Float_t gRedEmission[];	extern const Float_t gRedEmission[];
	extern const Float_t gGreenEmission[];	extern const Float_t gGreenEmission[];
	extern const Float_t gBlueEmission[];	extern const Float_t gBlueEmission[];
	extern const Float_t gOrangeEmission[];	extern const Float_t gOrangeEmission[];
	extern const Float_t gWhiteEmission[];	extern const Float_t gWhiteEmission[];
	extern const Float_t gGrayEmission[];	extern const Float_t gGrayEmission[];
	extern const Float_t gNullEmission[];	extern const Float_t gNullEmission[];

	typedef std::pair<Int_t, Int_t> BinRange_t;	typedef std::pair<Int_t, Int_t> BinRange_t;
	typedef std::pair<Double_t, Double_t> Range_t;	typedef std::pair<Double_t, Double_t> Range_t;

	void ObjectIDToColor(Int_t objectID, Bool_t highColor);	void ObjectIDToColor(Int_t objectID, Bool_t highColor);
	Int_t ColorToObjectID(const UChar_t *color, Bool_t highColor);	Int_t ColorToObjectID(const UChar_t *color, Bool_t highColor);
	void DrawQuadOutline(const TGLVertex3 &v1, const TGLVertex3 &v2,	void DrawQuadOutline(const TGLVertex3 &v1, const TGLVertex3 &v2,
	const TGLVertex3 &v3, const TGLVertex3 &v4);	const TGLVertex3 &v3, const TGLVertex3 &v4);
	void DrawQuadFilled(const TGLVertex3 &v0, const TGLVertex3 &v1,	void DrawQuadFilled(const TGLVertex3 &v0, const TGLVertex3 &v1,
	const TGLVertex3 &v2, const TGLVertex3 &v3,	const TGLVertex3 &v2, const TGLVertex3 &v3,
	const TGLVector3 &normal);	const TGLVector3 &normal);
	void DrawSmoothFace(const TGLVertex3 &v1, const TGLVertex3 &v2,	void DrawQuadFilled(const Double_t v0, const Double_t v1,
	const TGLVertex3 &v3, const TGLVector3 &norm1,	const Double_t v2, const Double_t v3,
	const TGLVector3 &norm2, const TGLVector3 &norm3);	const Double_t *normal);
	void DrawBoxFront(Double_t xMin, Double_t xMax, Double_t yMin, Double_t
	yMax,	void DrawSmoothFace(const TGLVertex3 &v1, const TGLVertex3 &v2,
	Double_t zMin, Double_t zMax, Int_t fp);	const TGLVertex3 &v3, const TGLVector3 &norm1,
		const TGLVector3 &norm2, const TGLVector3 &norm3);
	void DrawBoxFrontTextured(Double_t xMin, Double_t xMax, Double_t yMin,	void DrawBoxFront(Double_t xMin, Double_t xMax, Double_t yMin, Double_t yMa
	Double_t yMax, Double_t zMin, Double_t zMax,	x,
	Double_t tMin, Double_t tMax, Int_t front);	Double_t zMin, Double_t zMax, Int_t fp);

		void DrawBoxFrontTextured(Double_t xMin, Double_t xMax, Double_t yMin,
		Double_t yMax, Double_t zMin, Double_t zMax,
		Double_t tMin, Double_t tMax, Int_t front);

	#ifndef __CINT__	#ifndef __CINT__

	void DrawTrapezoidTextured(const Double_t ver[][2], Double_t zMin, Doubl	void DrawTrapezoidTextured(const Double_t ver[][2], Double_t zMin, Double_t
	e_t zMax,	zMax,
	Double_t tMin, Double_t tMax);	Double_t tMin, Double_t tMax);
	void DrawTrapezoidTextured(const Double_t ver[][3], Double_t texMin, Dou	void DrawTrapezoidTextured(const Double_t ver[][3], Double_t texMin, Double
	ble_t texMax);	_t texMax);
	void DrawTrapezoidTextured2(const Double_t ver[][2], Double_t zMin, Doub	void DrawTrapezoidTextured2(const Double_t ver[][2], Double_t zMin, Double_
	le_t zMax,	t zMax,
	Double_t tMin, Double_t tMax);	Double_t tMin, Double_t tMax);
	#endif	#endif


	void DrawCylinder(TGLQuadric *quadric, Double_t xMin, Double_t xMax, Dou	void DrawCylinder(TGLQuadric *quadric, Double_t xMin, Double_t xMax, Double
	ble_t yMin,	_t yMin,
	Double_t yMax, Double_t zMin, Double_t zMax);
	void DrawSphere(TGLQuadric *quadric, Double_t xMin, Double_t xMax, Doubl
	e_t yMin,
	Double_t yMax, Double_t zMin, Double_t zMax);
	void DrawError(Double_t xMin, Double_t xMax, Double_t yMin,
	Double_t yMax, Double_t zMin, Double_t zMax);	Double_t yMax, Double_t zMin, Double_t zMax);

		void DrawSphere(TGLQuadric *quadric, Double_t xMin, Double_t xMax, Double_t
		yMin,
		Double_t yMax, Double_t zMin, Double_t zMax);
		void DrawError(Double_t xMin, Double_t xMax, Double_t yMin,
		Double_t yMax, Double_t zMin, Double_t zMax);

	#ifndef __CINT__	#ifndef __CINT__

	void DrawTrapezoid(const Double_t ver[][2], Double_t zMin, Double_t zMax	void DrawTrapezoid(const Double_t ver[][2], Double_t zMin, Double_t zMax, B
	, Bool_t color = kTRUE);	ool_t color = kTRUE);
	void DrawTrapezoid(const Double_t ver[][3]);	void DrawTrapezoid(const Double_t ver[][3]);
	#endif	#endif


	void DrawAxes(Int_t frontPoint, const Int_t *viewport, const TGLVertex3	void DrawAxes(Int_t frontPoint, const Int_t viewport, const TGLVertex3 bo
	*box2D,	x2D,
	const TGLPlotCoordinates plotCoord, TAxis xAxis, TAxis *	const TGLPlotCoordinates plotCoord, TAxis xAxis, TAxis *yAx
	yAxis,	is,
	TAxis *zAxis);	TAxis *zAxis);
	void SetZLevels(TAxis *zAxis, Double_t zMin, Double_t zMax,	void SetZLevels(TAxis *zAxis, Double_t zMin, Double_t zMax,
	Double_t zScale, std::vector<Double_t> &zLevels);	Double_t zScale, std::vector<Double_t> &zLevels);

	void DrawFaceTextured(const TGLVertex3 &v1, const TGLVertex3 &v2, const	void DrawFaceTextured(const TGLVertex3 &v1, const TGLVertex3 &v2, const TGL
	TGLVertex3 &v3,	Vertex3 &v3,
	Double_t t1, Double_t t2, Double_t t3, const TGLVe	Double_t t1, Double_t t2, Double_t t3, const TGLVecto
	ctor3 &norm1,	r3 &norm1,
	const TGLVector3 &norm2, const TGLVector3 &norm3);	const TGLVector3 &norm2, const TGLVector3 &norm3);
	void DrawFaceTextured(const TGLVertex3 &v1, const TGLVertex3 &v2, const	void DrawFaceTextured(const TGLVertex3 &v1, const TGLVertex3 &v2, const TGL
	TGLVertex3 &v3,	Vertex3 &v3,
	Double_t t1, Double_t t2, Double_t t3, Double_t z,	Double_t t1, Double_t t2, Double_t t3, Double_t z, co
	const TGLVector3 &planeNormal);	nst TGLVector3 &planeNormal);
	void GetColor(Float_t v, Float_t vmin, Float_t vmax, Int_t type, Float_t	void GetColor(Float_t v, Float_t vmin, Float_t vmax, Int_t type, Float_t *r
	*rgba);	gba);

	class TGuardBase {
	private:
	mutable Bool_t fActive;

	TGuardBase &operator = (const TGuardBase &rhs);
	protected:
	TGuardBase()
	: fActive(kTRUE)
	{
	}
	TGuardBase(const TGuardBase &rhs)
	: fActive(kTRUE)
	{
	rhs.fActive = kFALSE;
	}

	Bool_t IsActive()const
	{
	return fActive;
	}


	public:	class TGuardBase {
	void Stop()const	private:
	{	mutable Bool_t fActive;
	fActive = kFALSE;
	}
	};


	template<class Func, class Arg>	TGuardBase &operator = (const TGuardBase &rhs);
	class TOneArgGuard : public TGuardBase {	protected:
	private:	TGuardBase()
	Func fFunc;	: fActive(kTRUE)
	Arg fArg;	{
	public:	}
	TOneArgGuard(Func f, Arg a)	TGuardBase(const TGuardBase &rhs)
	: fFunc(f), fArg(a)	: fActive(kTRUE)
	{	{
	}	rhs.fActive = kFALSE;
	~TOneArgGuard()	}
	{
	if (IsActive())
	fFunc(fArg);
	}
	};


	template<class Func, class Arg1, class Arg2>	Bool_t IsActive()const
	class TTwoArgsGuard : public TGuardBase {	{
	private:	return fActive;
	Func fFunc;	}
	Arg1 fArg1;
	Arg2 fArg2;


	public:	public:
	TTwoArgsGuard(Func f, Arg1 a1, Arg2 a2)	void Stop()const
	: fFunc(f), fArg1(a1), fArg2(a2)	{
	{	fActive = kFALSE;
	}	}
	~TTwoArgsGuard()	};
	{
	if (IsActive())
	fFunc(fArg1, fArg2);
	}
	};


	template<class Func, class Arg>	template<class Func, class Arg>
	TOneArgGuard<Func, Arg> make_guard(Func f, Arg a)	class TOneArgGuard : public TGuardBase {
		private:
		Func fFunc;
		Arg fArg;
		public:
		TOneArgGuard(Func f, Arg a)
		: fFunc(f), fArg(a)
	{	{

	return TOneArgGuard<Func, Arg>(f, a);
	}	}

		~TOneArgGuard()
		{
		if (IsActive())
		fFunc(fArg);
		}
		};


	template<class Func, class Arg1, class Arg2>	template<class Func, class Arg1, class Arg2>
	TTwoArgsGuard<Func, Arg1, Arg2> make_guard(Func f, Arg1 a1, Arg2 a2)	class TTwoArgsGuard : public TGuardBase {
		private:
		Func fFunc;
		Arg1 fArg1;
		Arg2 fArg2;

		public:
		TTwoArgsGuard(Func f, Arg1 a1, Arg2 a2)
		: fFunc(f), fArg1(a1), fArg2(a2)
	{	{

	return TTwoArgsGuard<Func, Arg1, Arg2>(f, a1, a2);
	}	}

		~TTwoArgsGuard()
		{
		if (IsActive())
		fFunc(fArg1, fArg2);
		}
		};

		template<class Func, class Arg>
		TOneArgGuard<Func, Arg> make_guard(Func f, Arg a)
		{
		return TOneArgGuard<Func, Arg>(f, a);
	}	}


		template<class Func, class Arg1, class Arg2>
		TTwoArgsGuard<Func, Arg1, Arg2> make_guard(Func f, Arg1 a1, Arg2 a2)
		{
		return TTwoArgsGuard<Func, Arg1, Arg2>(f, a1, a2);
		}

		}//namespace Rgl.

	class TGLLevelPalette {	class TGLLevelPalette {
	private:	private:
	std::vector<UChar_t> fTexels;	std::vector<UChar_t> fTexels;
	const std::vector<Double_t> *fContours;	const std::vector<Double_t> *fContours;
	UInt_t fPaletteSize;	UInt_t fPaletteSize;
	mutable UInt_t fTexture;	mutable UInt_t fTexture;
	Int_t fMaxPaletteSize;	Int_t fMaxPaletteSize;
	Rgl::Range_t fZRange;	Rgl::Range_t fZRange;

	TGLLevelPalette(const TGLLevelPalette&); // Not implemented	TGLLevelPalette(const TGLLevelPalette&); // Not implemented

End of changes. 18 change blocks.
	132 lines changed or deleted	137 lines changed or added

	TGLViewer.h	TGLViewer.h

	// @(#)root/gl:$Id: TGLViewer.h 33864 2010-06-14 09:47:19Z matevz $	// @(#)root/gl:$Id: TGLViewer.h 37327 2010-12-06 12:23:33Z matevz $
	// Author: Richard Maunder 25/05/2005	// Author: Richard Maunder 25/05/2005

	/*************************************************************************	/*************************************************************************
	* 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 45	skipping to change at line 45

	class TGLSceneBase;	class TGLSceneBase;
	class TGLRedrawTimer;	class TGLRedrawTimer;
	class TGLViewerEditor;	class TGLViewerEditor;
	class TGLWidget;	class TGLWidget;
	class TGLLightSet;	class TGLLightSet;
	class TGLClipSet;	class TGLClipSet;
	class TGLManipSet;	class TGLManipSet;
	class TGLCameraOverlay;	class TGLCameraOverlay;
	class TGLContextIdentity;	class TGLContextIdentity;

		class TGLAutoRotator;
	class TTimer;	class TTimer;

	class TContextMenu;	class TContextMenu;
	class TGedEditor;	class TGedEditor;
	class TGLPShapeObj;	class TGLPShapeObj;

	class TGLViewer : public TVirtualViewer3D,	class TGLViewer : public TVirtualViewer3D,
	public TGLViewerBase,	public TGLViewerBase,
	public TQObject	public TQObject


	skipping to change at line 94	skipping to change at line 95
	TGLPerspectiveCamera fPerspectiveCameraXOZ; //!	TGLPerspectiveCamera fPerspectiveCameraXOZ; //!
	TGLPerspectiveCamera fPerspectiveCameraYOZ; //!	TGLPerspectiveCamera fPerspectiveCameraYOZ; //!
	TGLPerspectiveCamera fPerspectiveCameraXOY; //!	TGLPerspectiveCamera fPerspectiveCameraXOY; //!
	TGLOrthoCamera fOrthoXOYCamera; //!	TGLOrthoCamera fOrthoXOYCamera; //!
	TGLOrthoCamera fOrthoXOZCamera; //!	TGLOrthoCamera fOrthoXOZCamera; //!
	TGLOrthoCamera fOrthoZOYCamera; //!	TGLOrthoCamera fOrthoZOYCamera; //!
	TGLOrthoCamera fOrthoXnOYCamera; //!	TGLOrthoCamera fOrthoXnOYCamera; //!
	TGLOrthoCamera fOrthoXnOZCamera; //!	TGLOrthoCamera fOrthoXnOZCamera; //!
	TGLOrthoCamera fOrthoZnOYCamera; //!	TGLOrthoCamera fOrthoZnOYCamera; //!
	TGLCamera *fCurrentCamera; //!	TGLCamera *fCurrentCamera; //!

		TGLAutoRotator *fAutoRotator; //!

	// Stereo	// Stereo
	Bool_t fStereo; //! use stereo rendering	Bool_t fStereo; //! use stereo rendering
	Float_t fStereoZeroParallax; //! position of zero-paralla x plane: 0 - near clipping plane, 1 - far clipping plane	Float_t fStereoZeroParallax; //! position of zero-paralla x plane: 0 - near clipping plane, 1 - far clipping plane
	Float_t fStereoEyeOffsetFac; //!	Float_t fStereoEyeOffsetFac; //!
	Float_t fStereoFrustumAsymFac; //!	Float_t fStereoFrustumAsymFac; //!

	// Lights	// Lights
	TGLLightSet *fLightSet; //!	TGLLightSet *fLightSet; //!
	// Clipping	// Clipping

	skipping to change at line 148	skipping to change at line 150
	Float_t fLineScale; //! width scale for lines	Float_t fLineScale; //! width scale for lines
	Bool_t fSmoothPoints; //! smooth point edge rendering	Bool_t fSmoothPoints; //! smooth point edge rendering
	Bool_t fSmoothLines; //! smooth line edge rendering	Bool_t fSmoothLines; //! smooth line edge rendering
	Int_t fAxesType; //! axes type	Int_t fAxesType; //! axes type
	Bool_t fAxesDepthTest; //! remove guides hidden-lines	Bool_t fAxesDepthTest; //! remove guides hidden-lines
	Bool_t fReferenceOn; //! reference marker on?	Bool_t fReferenceOn; //! reference marker on?
	TGLVertex3 fReferencePos; //! reference position	TGLVertex3 fReferencePos; //! reference position
	Bool_t fDrawCameraCenter; //! reference marker on?	Bool_t fDrawCameraCenter; //! reference marker on?
	TGLCameraOverlay *fCameraOverlay; //! markup size of viewport in scene units	TGLCameraOverlay *fCameraOverlay; //! markup size of viewport in scene units


	Bool_t fInitGL; //! has GL been initialised?	Bool_t fSmartRefresh; //! cache logicals during scene rebuilds
	Bool_t fSmartRefresh; //! cache logicals during scene rebuilds
	, use TAtt3D time-stamp to determine if they are still valid

	// Debug tracing (for scene rebuilds)	// Debug tracing (for scene rebuilds)
	Bool_t fDebugMode; //! debug mode (forced rebuild + d raw scene/frustum/interest boxes)	Bool_t fDebugMode; //! debug mode (forced rebuild + d raw scene/frustum/interest boxes)
	Bool_t fIsPrinting; //!	Bool_t fIsPrinting; //!
	TString fPictureFileName; //! default file-name for SavePict ure()	TString fPictureFileName; //! default file-name for SavePict ure()
	Float_t fFader; //! fade the view (0 - no fade/def ault, 1 - full fade/no rendering done)	Float_t fFader; //! fade the view (0 - no fade/def ault, 1 - full fade/no rendering done)

	static TGLColorSet fgDefaultColorSet; //! a shared, defa ult color-set	static TGLColorSet fgDefaultColorSet; //! a shared, defa ult color-set
	static Bool_t fgUseDefaultColorSetForNewViewers; //! name says it a ll	static Bool_t fgUseDefaultColorSetForNewViewers; //! name says it a ll


	skipping to change at line 194	skipping to change at line 195
	// Updata/camera-reset behaviour	// Updata/camera-reset behaviour
	Bool_t fIgnoreSizesOnUpdate; // ignore sizes of bounding- boxes on update	Bool_t fIgnoreSizesOnUpdate; // ignore sizes of bounding- boxes on update
	Bool_t fResetCamerasOnUpdate; // reposition camera on each update	Bool_t fResetCamerasOnUpdate; // reposition camera on each update
	Bool_t fResetCamerasOnNextUpdate; // reposition camera on next update	Bool_t fResetCamerasOnNextUpdate; // reposition camera on next update

	public:	public:
	TGLViewer(TVirtualPad* pad, Int_t x, Int_t y, Int_t width, Int_t height) ;	TGLViewer(TVirtualPad* pad, Int_t x, Int_t y, Int_t width, Int_t height) ;
	TGLViewer(TVirtualPad* pad);	TGLViewer(TVirtualPad* pad);
	virtual ~TGLViewer();	virtual ~TGLViewer();


	void ResetInitGL();

	// TVirtualViewer3D interface ... mostly a facade	// TVirtualViewer3D interface ... mostly a facade

	// Forward to TGLScenePad	// Forward to TGLScenePad
	virtual Bool_t CanLoopOnPrimitives() const { return kTRUE; }	virtual Bool_t CanLoopOnPrimitives() const { return kTRUE; }
	virtual void PadPaint(TVirtualPad* pad);	virtual void PadPaint(TVirtualPad* pad);
	// Actually used by GL-in-pad	// Actually used by GL-in-pad
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
	virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);	virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
	// Only implemented because they're abstract ... should throw an	// Only implemented because they're abstract ... should throw an
	// exception or assert they are not called.	// exception or assert they are not called.

	skipping to change at line 279	skipping to change at line 278
	void SetPerspectiveCamera(ECameraType camera, Double_t fov, Double_t dol ly,	void SetPerspectiveCamera(ECameraType camera, Double_t fov, Double_t dol ly,
	Double_t center[3], Double_t hRotate, Double_t vRotate);	Double_t center[3], Double_t hRotate, Double_t vRotate);
	void GetGuideState(Int_t & axesType, Bool_t & axesDepthTest, Bool_t & re ferenceOn, Double_t* referencePos) const;	void GetGuideState(Int_t & axesType, Bool_t & axesDepthTest, Bool_t & re ferenceOn, Double_t* referencePos) const;
	void SetGuideState(Int_t axesType, Bool_t axesDepthTest, Bool_t referenc eOn, const Double_t* referencePos);	void SetGuideState(Int_t axesType, Bool_t axesDepthTest, Bool_t referenc eOn, const Double_t* referencePos);
	void SetDrawCameraCenter(Bool_t x);	void SetDrawCameraCenter(Bool_t x);
	Bool_t GetDrawCameraCenter() { return fDrawCameraCenter; }	Bool_t GetDrawCameraCenter() { return fDrawCameraCenter; }
	void PickCameraCenter() { fPushAction = kPushCamCenter; RefreshPadE ditor(this); }	void PickCameraCenter() { fPushAction = kPushCamCenter; RefreshPadE ditor(this); }
	void PickAnnotate() { fPushAction = kPushAnnotate; RefreshPadE ditor(this); }	void PickAnnotate() { fPushAction = kPushAnnotate; RefreshPadE ditor(this); }
	TGLCameraOverlay* GetCameraOverlay() const { return fCameraOverlay; }	TGLCameraOverlay* GetCameraOverlay() const { return fCameraOverlay; }
	void SetCameraOverlay(TGLCameraOverlay* m) { fCameraOverlay = m; }	void SetCameraOverlay(TGLCameraOverlay* m) { fCameraOverlay = m; }

		TGLAutoRotator* GetAutoRotator();
		void SetAutoRotator(TGLAutoRotator* ar);

	// Stereo	// Stereo
	Bool_t GetStereo() const { return fStereo; }	Bool_t GetStereo() const { return fStereo; }
	Float_t GetStereoZeroParallax() const { return fStereoZeroParallax; }	Float_t GetStereoZeroParallax() const { return fStereoZeroParallax; }
	Float_t GetStereoEyeOffsetFac() const { return fStereoEyeOffsetFac; }	Float_t GetStereoEyeOffsetFac() const { return fStereoEyeOffsetFac; }
	Float_t GetStereoFrustumAsymFac() const { return fStereoFrustumAsymFac; }	Float_t GetStereoFrustumAsymFac() const { return fStereoFrustumAsymFac; }

	void SetStereo(Bool_t s) { fStereo = s; }	void SetStereo(Bool_t s) { fStereo = s; }
	void SetStereoZeroParallax(Float_t f) { fStereoZeroParallax = f; }	void SetStereoZeroParallax(Float_t f) { fStereoZeroParallax = f; }
	void SetStereoEyeOffsetFac(Float_t f) { fStereoEyeOffsetFac = f; }	void SetStereoEyeOffsetFac(Float_t f) { fStereoEyeOffsetFac = f; }

	skipping to change at line 309	skipping to change at line 310
	// Scene rendering timeouts	// Scene rendering timeouts
	Float_t GetMaxSceneDrawTimeHQ() const { return fMaxSceneDrawTimeHQ; }	Float_t GetMaxSceneDrawTimeHQ() const { return fMaxSceneDrawTimeHQ; }
	Float_t GetMaxSceneDrawTimeLQ() const { return fMaxSceneDrawTimeLQ; }	Float_t GetMaxSceneDrawTimeLQ() const { return fMaxSceneDrawTimeLQ; }
	void SetMaxSceneDrawTimeHQ(Float_t t) { fMaxSceneDrawTimeHQ = t; }	void SetMaxSceneDrawTimeHQ(Float_t t) { fMaxSceneDrawTimeHQ = t; }
	void SetMaxSceneDrawTimeLQ(Float_t t) { fMaxSceneDrawTimeLQ = t; }	void SetMaxSceneDrawTimeLQ(Float_t t) { fMaxSceneDrawTimeLQ = t; }

	// Request methods post cross thread request via TROOT::ProcessLineFast( ).	// Request methods post cross thread request via TROOT::ProcessLineFast( ).
	void RequestDraw(Short_t LOD = TGLRnrCtx::kLODMed); // Cross thread draw request	void RequestDraw(Short_t LOD = TGLRnrCtx::kLODMed); // Cross thread draw request
	virtual void PreRender();	virtual void PreRender();
	virtual void PostRender();	virtual void PostRender();

	void DoDraw();	void DoDraw(Bool_t swap_buffers=kTRUE);
	void DoDrawMono();	void DoDrawMono(Bool_t swap_buffers);
	void DoDrawStereo();	void DoDrawStereo(Bool_t swap_buffers);

	void DrawGuides();	void DrawGuides();
	void DrawDebugInfo();	void DrawDebugInfo();

	Bool_t RequestSelect(Int_t x, Int_t y); // Cross thread select request	Bool_t RequestSelect(Int_t x, Int_t y); // Cross thread select request
	Bool_t DoSelect(Int_t x, Int_t y); // First level selecton (shapes/objects).	Bool_t DoSelect(Int_t x, Int_t y); // First level selecton (shapes/objects).
	Bool_t RequestSecondarySelect(Int_t x, Int_t y); // Cross thread seconda ry select request	Bool_t RequestSecondarySelect(Int_t x, Int_t y); // Cross thread seconda ry select request
	Bool_t DoSecondarySelect(Int_t x, Int_t y); // Second level selecto n (inner structure).	Bool_t DoSecondarySelect(Int_t x, Int_t y); // Second level selecto n (inner structure).
	void ApplySelection();	void ApplySelection();


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

	TGLViewerEditor.h	TGLViewerEditor.h

	skipping to change at line 94	skipping to change at line 94
	TGNumberEntry *fReferencePosX;	TGNumberEntry *fReferencePosX;
	TGNumberEntry *fReferencePosY;	TGNumberEntry *fReferencePosY;
	TGNumberEntry *fReferencePosZ;	TGNumberEntry *fReferencePosZ;

	TGGroupFrame *fCamContainer;	TGGroupFrame *fCamContainer;
	TGComboBox* fCamMode;	TGComboBox* fCamMode;
	TGCheckButton* fCamOverlayOn;	TGCheckButton* fCamOverlayOn;

	TGLClipSetSubEditor *fClipSet;	TGLClipSetSubEditor *fClipSet;


		TGNumberEntry fARotDt, fARotWPhi;
		TGNumberEntry fARotATheta, fARotWTheta;
		TGNumberEntry fARotADolly, fARotWDolly;

	TGNumberEntry *fStereoZeroParallax;	TGNumberEntry *fStereoZeroParallax;
	TGNumberEntry *fStereoEyeOffsetFac;	TGNumberEntry *fStereoEyeOffsetFac;
	TGNumberEntry *fStereoFrustumAsymFac;	TGNumberEntry *fStereoFrustumAsymFac;

	//Model	//Model
	TGLViewer *fViewer;	TGLViewer *fViewer;
	Bool_t fIsInPad;	Bool_t fIsInPad;

	void ConnectSignals2Slots();	void ConnectSignals2Slots();

	TGLViewerEditor(const TGLViewerEditor &);	TGLViewerEditor(const TGLViewerEditor &);
	TGLViewerEditor &operator = (const TGLViewerEditor &);	TGLViewerEditor &operator = (const TGLViewerEditor &);

	void CreateStyleTab();	void CreateStyleTab();
	void CreateGuidesTab();	void CreateGuidesTab();
	void CreateClippingTab();	void CreateClippingTab();

	void CreateStereoTab();	void CreateExtrasTab();

	void UpdateReferencePosState();	void UpdateReferencePosState();

	public:	public:
	TGLViewerEditor(const TGWindow *p=0, Int_t width=140, Int_t height=30,	TGLViewerEditor(const TGWindow *p=0, Int_t width=140, Int_t height=30,
	UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrame Background());	UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrame Background());
	~TGLViewerEditor();	~TGLViewerEditor();

	virtual void ViewerRedraw();	virtual void ViewerRedraw();


	skipping to change at line 140	skipping to change at line 144
	void UpdatePointLineStuff();	void UpdatePointLineStuff();
	void DoCameraCenterExt();	void DoCameraCenterExt();
	void DoCaptureCenter();	void DoCaptureCenter();
	void DoAnnotation();	void DoAnnotation();
	void DoDrawCameraCenter();	void DoDrawCameraCenter();
	void UpdateCameraCenter();	void UpdateCameraCenter();
	//Axis manipulation	//Axis manipulation
	void UpdateViewerAxes(Int_t id);	void UpdateViewerAxes(Int_t id);
	void UpdateViewerReference();	void UpdateViewerReference();
	void DoCameraOverlay();	void DoCameraOverlay();

	// Stereo	// Extras
		void UpdateRotator();
		void DoRotatorStart();
		void DoRotatorStop();
	void UpdateStereo();	void UpdateStereo();

	void DetachFromPad(){fIsInPad = kFALSE;}	void DetachFromPad(){fIsInPad = kFALSE;}

	static TGNumberEntry* MakeLabeledNEntry(TGCompositeFrame* p, const char* name,	static TGNumberEntry* MakeLabeledNEntry(TGCompositeFrame* p, const char* name,
	Int_t labelw, Int_t nd=7, Int_t s=5);	Int_t labelw, Int_t nd=7, Int_t s=5);

	ClassDef(TGLViewerEditor, 0); //GUI for editing TGLViewer attributes	ClassDef(TGLViewerEditor, 0); //GUI for editing TGLViewer attributes
	};	};


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

	TGLWSIncludes.h	TGLWSIncludes.h

	// @(#)root/gl:$Id: TGLWSIncludes.h 29056 2009-06-17 14:36:59Z matevz $	// @(#)root/gl:$Id: TGLWSIncludes.h 36706 2010-11-16 18:48:09Z matevz $
	/*************************************************************************	/*************************************************************************
	* 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. *
	*************************************************************************/	*************************************************************************/

	// Window-system specific GL includes.	// Window-system specific GL includes.
	// Inclusion should only be necessary in in low-level system files.	// Inclusion should only be necessary in in low-level system files.

	#ifndef ROOT_TGLWSIncludes	#ifndef ROOT_TGLWSIncludes

	#include "TGLIncludes.h"	#include "TGLIncludes.h"


	#ifdef WIN32	#if defined(WIN32)
	#include <GL/wglew.h>	# include <GL/wglew.h>
	#else	#else

	#include <GL/glxew.h>	# if defined(__APPLE__)
		# define GLEW_APPLE_GLX
		# endif
		# include <GL/glxew.h>
	#endif	#endif

	#endif	#endif

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

	TGLWidget.h	TGLWidget.h

	// @(#)root/gl:$Id: TGLWidget.h 26250 2008-11-17 20:56:44Z matevz $	// @(#)root/gl:$Id: TGLWidget.h 36675 2010-11-15 20:33:58Z matevz $
	/*************************************************************************	/*************************************************************************
	* 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. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TGLWidget	#ifndef ROOT_TGLWidget
	#define ROOT_TGLWidget	#define ROOT_TGLWidget

	skipping to change at line 52	skipping to change at line 52

	TGLFormat fGLFormat;	TGLFormat fGLFormat;
	//fFromCtor checks that SetFormat was called only from ctor.	//fFromCtor checks that SetFormat was called only from ctor.
	Bool_t fFromInit;	Bool_t fFromInit;

	std::set<TGLContext *> fValidContexts;	std::set<TGLContext *> fValidContexts;

	TGEventHandler *fEventHandler;	TGEventHandler *fEventHandler;

	public:	public:

		static TGLWidget* CreateDummy();

	static TGLWidget* Create(const TGWindow* parent, Bool_t selectInput,	static TGLWidget* Create(const TGWindow* parent, Bool_t selectInput,
	Bool_t shareDefault, const TGLPaintDevice *shareDevice,	Bool_t shareDefault, const TGLPaintDevice *shareDevice,
	UInt_t width, UInt_t height);	UInt_t width, UInt_t height);

	static TGLWidget* Create(const TGLFormat &format,	static TGLWidget* Create(const TGLFormat &format,
	const TGWindow* parent, Bool_t selectInput,	const TGWindow* parent, Bool_t selectInput,
	Bool_t shareDefault, const TGLPaintDevice *shareDevice,	Bool_t shareDefault, const TGLPaintDevice *shareDevice,
	UInt_t width, UInt_t height);	UInt_t width, UInt_t height);

	~TGLWidget();	~TGLWidget();

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

	TGenCollectionProxy.h	TGenCollectionProxy.h

	// @(#)root/io:$Id: TGenCollectionProxy.h 31136 2009-11-12 21:25:38Z pcanal $	// @(#)root/io:$Id: TGenCollectionProxy.h 36061 2010-10-04 16:05:51Z pcanal $
	// Author: Markus Frank 28/10/04	// Author: Markus Frank 28/10/04

	/*************************************************************************	/*************************************************************************
	* 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. *
	*************************************************************************/	*************************************************************************/
	#ifndef ROOT_TGenCollectionProxy	#ifndef ROOT_TGenCollectionProxy

	skipping to change at line 28	skipping to change at line 28
	// Proxy around an arbitrary container, which implements basic	// Proxy around an arbitrary container, which implements basic
	// functionality and iteration.	// functionality and iteration.
	//	//
	// In particular this is used to implement splitting and abstract	// In particular this is used to implement splitting and abstract
	// element access of any container. Access to compiled code is necessary	// element access of any container. Access to compiled code is necessary
	// to implement the abstract iteration sequence and functionality like	// to implement the abstract iteration sequence and functionality like
	// size(), clear(), resize(). resize() may be a void operation.	// size(), clear(), resize(). resize() may be a void operation.
	//	//
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////


		#ifndef ROOT_TVirtualCollectionProxy
	#include "TVirtualCollectionProxy.h"	#include "TVirtualCollectionProxy.h"

	#include "TCollectionProxyFactory.h"	#endif

		#ifndef ROOT_TCollectionProxyInfo
		#include "TCollectionProxyInfo.h"
		#endif

	#include <typeinfo>	#include <typeinfo>
	#include <string>	#include <string>

		#include <map>
		#ifndef __CINT__
		#if defined(__APPLE__)
		#include <stdlib.h>
		#else
		#include <malloc.h>
		#endif
		#endif
		class TObjArray;
		class TCollectionProxyFactory;

	class TGenCollectionProxy	class TGenCollectionProxy
	: public TVirtualCollectionProxy	: public TVirtualCollectionProxy
	{	{

	// Friend declaration	// Friend declaration
	friend class TCollectionProxyFactory;	friend class TCollectionProxyFactory;

	public:	public:


	skipping to change at line 226	skipping to change at line 242
	class Method0 {	class Method0 {
	public:	public:
	typedef void* (*Call_t)();	typedef void* (*Call_t)();
	Call_t call;	Call_t call;
	Method0() : call(0) { }	Method0() : call(0) { }
	Method0(Call_t c) : call(c) { }	Method0(Call_t c) : call(c) { }
	Method0(const Method0& m) : call(m.call) { }	Method0(const Method0& m) : call(m.call) { }
	void* invoke() const { return (*call)(); }	void* invoke() const { return (*call)(); }
	};	};


		/** @class TGenCollectionProxy::TStaging
		*
		* Small helper to stage the content of an associative
		* container when reading and before inserting it in the
		* actual collection.
		*
		* @author Ph.Canal
		* @version 1.0
		* @date 20/08/2010
		*/
		class TStaging {
		void *fTarget; // Pointer to the collection we are staging for.
		void *fContent; // Pointer to the content
		size_t fReserved; // Amount of space already reserved.
		size_t fSize; // Number of elements
		size_t fSizeOf; // size of each elements
		public:
		TStaging(size_t size, size_t size_of) : fTarget(0), fContent(0), fRes
		erved(0), fSize(size), fSizeOf(size_of)
		{
		// Usual constructor. Reserves the required number of elements.
		fReserved = fSize;
		fContent = ::malloc(fReserved * fSizeOf);
		}

		~TStaging() {
		// Usual destructor
		::free(fContent);
		}

		void *GetContent() {
		// Return the location of the array of content.
		return fContent;
		}
		void *GetEnd() {
		// Return the 'end' of the array of content.
		return ((char)fContent) + fSizefSizeOf;
		}
		size_t GetSize() {
		// Return the number of elements.
		return fSize;
		}
		void *GetTarget() {
		// Get the address of the collection we are staging for.
		return fTarget;
		}
		void Resize(size_t nelement) {
		if (fReserved < nelement) {
		fReserved = nelement;
		fContent = ::realloc(fContent,fReserved * fSizeOf);
		}
		fSize = nelement;
		}
		void SetTarget(void *target) {
		// Set the collection we are staging for.
		fTarget = target;
		}
		};

	protected:	protected:
	typedef ROOT::TCollectionProxyInfo::Environ<char[64]> Env_t;	typedef ROOT::TCollectionProxyInfo::Environ<char[64]> Env_t;
	typedef ROOT::TCollectionProxyInfo::EnvironBase EnvironBase_t;	typedef ROOT::TCollectionProxyInfo::EnvironBase EnvironBase_t;

		typedef std::vector<TStaging*> Staged_t; // Collection of pre- allocated staged array for associative containers.
	typedef std::vector<EnvironBase_t*> Proxies_t;	typedef std::vector<EnvironBase_t*> Proxies_t;

		mutable TObjArray *fReadMemberWise; //
		Array of bundle of TStreamerInfoActions to stream out (read)
		mutable std::map<std::string, TObjArray> fConversionReadMemberWise; //
		Array of bundle of TStreamerInfoActions to stream out (read) derived from a
		nother class.
		typedef void (Sizing_t)(void obj, size_t size);
		typedef void* (Feedfunc_t)(void from, void *to, size_t size);
		typedef void* (ArrIterfunc_t)(void from, size_t size);

	std::string fName; // Name of the class being proxied.	std::string fName; // Name of the class being proxied.
	Bool_t fPointers; // Flag to indicate if containee has pointers (key or value)	Bool_t fPointers; // Flag to indicate if containee has pointers (key or value)
	Method fClear; // Method cache for container accessors: clear container	Method fClear; // Method cache for container accessors: clear container
	Method fSize; // Container accessors: size of container	Method fSize; // Container accessors: size of container

	Method fResize; // Container accessors: resize container	Sizing_t fResize; // Container accessors: resize container
	Method fFirst; // Container accessors: generic iteration: fir st	Method fFirst; // Container accessors: generic iteration: fir st
	Method fNext; // Container accessors: generic iteration: nex t	Method fNext; // Container accessors: generic iteration: nex t

	Method fConstruct; // Container accessors: block construct	ArrIterfunc_t fConstruct; // Container accessors: block construct
	Method fDestruct; // Container accessors: block destruct	Sizing_t fDestruct; // Container accessors: block destruct
	Method fFeed; // Container accessors: block feed	Feedfunc_t fFeed; // Container accessors: block feed
	Method fCollect; // Method to collect objects from container	Method fCollect; // Method to collect objects from container
	Method0 fCreateEnv; // Method to allocate an Environment holder.	Method0 fCreateEnv; // Method to allocate an Environment holder.
	Value* fValue; // Descriptor of the container value type	Value* fValue; // Descriptor of the container value type
	Value* fVal; // Descriptor of the Value_type	Value* fVal; // Descriptor of the Value_type
	Value* fKey; // Descriptor of the key_type	Value* fKey; // Descriptor of the key_type
	EnvironBase_t*fEnv; // Address of the currently proxied object	EnvironBase_t*fEnv; // Address of the currently proxied object
	int fValOffset; // Offset from key to value (in maps)	int fValOffset; // Offset from key to value (in maps)
	int fValDiff; // Offset between two consecutive value_types (memory layout).	int fValDiff; // Offset between two consecutive value_types (memory layout).
	Proxies_t fProxyList; // Stack of recursive proxies	Proxies_t fProxyList; // Stack of recursive proxies
	Proxies_t fProxyKept; // Optimization: Keep proxies once they were c reated	Proxies_t fProxyKept; // Optimization: Keep proxies once they were c reated

		Staged_t fStaged; // Optimization: Keep staged array once they w ere created
	int fSTL_type; // STL container type	int fSTL_type; // STL container type
	Info_t fTypeinfo; // Type information	Info_t fTypeinfo; // Type information
	TClass* fOnFileClass; // On file class	TClass* fOnFileClass; // On file class


		CreateIterators_t fFunctionCreateIterators;
		DeleteTwoIterators_t fFunctionDeleteTwoIterators;

	// Late initialization of collection proxy	// Late initialization of collection proxy
	TGenCollectionProxy* Initialize() const;	TGenCollectionProxy* Initialize() const;
	// Some hack to avoid const-ness.	// Some hack to avoid const-ness.
	virtual TGenCollectionProxy* InitializeEx();	virtual TGenCollectionProxy* InitializeEx();
	// Call to delete/destruct individual contained item.	// Call to delete/destruct individual contained item.
	virtual void DeleteItem(Bool_t force, void* ptr) const;	virtual void DeleteItem(Bool_t force, void* ptr) const;
	// Allow to check function pointers.	// Allow to check function pointers.
	void CheckFunctions() const;	void CheckFunctions() const;

		private:
		TGenCollectionProxy(); // not implemented on purpose.

	public:	public:

	// Virtual copy constructor.	// Virtual copy constructor.
	virtual TVirtualCollectionProxy* Generate() const;	virtual TVirtualCollectionProxy* Generate() const;

	// Copy constructor.	// Copy constructor.
	TGenCollectionProxy(const TGenCollectionProxy& copy);	TGenCollectionProxy(const TGenCollectionProxy& copy);

	// Initializing constructor	// Initializing constructor
	TGenCollectionProxy(Info_t typ, size_t iter_size);	TGenCollectionProxy(Info_t typ, size_t iter_size);
	TGenCollectionProxy(const ROOT::TCollectionProxyInfo &info, TClass *cl);	TGenCollectionProxy(const ROOT::TCollectionProxyInfo &info, TClass *cl);

	// Standard destructor.	// Standard destructor.
	virtual ~TGenCollectionProxy();	virtual ~TGenCollectionProxy();

	// Return a pointer to the TClass representing the container.	// Return a pointer to the TClass representing the container.
	virtual TClass *GetCollectionClass();	virtual TClass *GetCollectionClass();


		// Return the type of collection see TClassEdit::ESTLType
		virtual Int_t GetCollectionType();

		// Return the offset between two consecutive value_types (memory layout)
		.
		virtual ULong_t GetIncrement();

	// Return the sizeof the collection object.	// Return the sizeof the collection object.
	virtual UInt_t Sizeof() const;	virtual UInt_t Sizeof() const;

	// Push new proxy environment.	// Push new proxy environment.
	virtual void PushProxy(void *objstart);	virtual void PushProxy(void *objstart);

	// Pop old proxy environment.	// Pop old proxy environment.
	virtual void PopProxy();	virtual void PopProxy();

	// Return true if the content is of type 'pointer to'.	// Return true if the content is of type 'pointer to'.

	skipping to change at line 330	skipping to change at line 422

	// Streamer function.	// Streamer function.
	virtual void Streamer(TBuffer &refBuffer);	virtual void Streamer(TBuffer &refBuffer);

	// Streamer I/O overload.	// Streamer I/O overload.
	virtual void Streamer(TBuffer &refBuffer, void *pObject, int siz);	virtual void Streamer(TBuffer &refBuffer, void *pObject, int siz);

	// TClassStreamer I/O overload.	// TClassStreamer I/O overload.
	virtual void operator()(TBuffer &refBuffer, void *pObject);	virtual void operator()(TBuffer &refBuffer, void *pObject);


		// Routine to read the content of the buffer into 'obj'.
		virtual void ReadBuffer(TBuffer &b, void *obj);
		virtual void ReadBuffer(TBuffer &b, void obj, const TClass onfileClass
		);

	virtual void SetOnFileClass( TClass* cl ) { fOnFileClass = cl; }	virtual void SetOnFileClass( TClass* cl ) { fOnFileClass = cl; }
	virtual TClass* GetOnFileClass() const { return fOnFileClass; }	virtual TClass* GetOnFileClass() const { return fOnFileClass; }


		// MemberWise actions
		virtual TStreamerInfoActions::TActionSequence *GetConversionReadMemberWi
		seActions(TClass *oldClass, Int_t version);
		virtual TStreamerInfoActions::TActionSequence *GetReadMemberWiseActions(
		Int_t version);
		virtual TStreamerInfoActions::TActionSequence *GetWriteMemberWiseActions
		();

		// Set of functions to iterate easily throught the collection

		virtual CreateIterators_t GetFunctionCreateIterators(Bool_t read = kTRUE
		);
		// typedef void (CreateIterators_t)(void collection, void **begin_aren
		a, void **end_arena);
		// begin_arena and end_arena should contain the location of a memory are
		na of size fgIteratorSize.
		// If the collection iterator are of that size or less, the iterators wi
		ll be constructed in place in those location (new with placement)
		// Otherwise the iterators will be allocated via a regular new and their
		address returned by modifying the value of begin_arena and end_arena.

		virtual CopyIterator_t GetFunctionCopyIterator(Bool_t read = kTRUE);
		// typedef void* (CopyIterator_t)(void dest, const void *source);
		// Copy the iterator source, into dest. dest should contain the locati
		on of a memory arena of size fgIteratorSize.
		// If the collection iterator is of that size or less, the iterator will
		be constructed in place in this location (new with placement)
		// Otherwise the iterator will be allocated via a regular new and its ad
		dress returned by modifying the value of dest.

		virtual Next_t GetFunctionNext(Bool_t read = kTRUE);
		// typedef void* (Next_t)(void iter, const void *end);
		// iter and end should be pointers to respectively an iterator to be inc
		remented and the result of collection.end()
		// If the iterator has not reached the end of the collection, 'Next' inc
		rement the iterator 'iter' and return 0 if
		// the iterator reached the end.
		// If the end was not reached, 'Next' returns the address of the content
		pointed to by the iterator before the
		// incrementation ; if the collection contains pointers, 'Next' will ret
		urn the value of the pointer.

		virtual DeleteIterator_t GetFunctionDeleteIterator(Bool_t read = kTRUE);
		virtual DeleteTwoIterators_t GetFunctionDeleteTwoIterators(Bool_t read =
		kTRUE);
		// typedef void (DeleteIterator_t)(void iter);
		// typedef void (DeleteTwoIterators_t)(void begin, void *end);
		// If the size of the iterator is greater than fgIteratorArenaSize, call
		delete on the addresses,
		// Otherwise just call the iterator's destructor.

	};	};

	template <typename T>	template <typename T>
	struct AnyCollectionProxy : public TGenCollectionProxy {	struct AnyCollectionProxy : public TGenCollectionProxy {
	AnyCollectionProxy()	AnyCollectionProxy()
	: TGenCollectionProxy(typeid(T::Cont_t),sizeof(T::Iter_t))	: TGenCollectionProxy(typeid(T::Cont_t),sizeof(T::Iter_t))
	{	{
	// Constructor.	// Constructor.
	fValDiff = sizeof(T::Value_t);	fValDiff = sizeof(T::Value_t);
	fValOffset = T::value_offset();	fValOffset = T::value_offset();
	fSize.call = T::size;	fSize.call = T::size;

	fResize.call = T::resize;	fResize = T::resize;
	fNext.call = T::next;	fNext.call = T::next;
	fFirst.call = T::first;	fFirst.call = T::first;
	fClear.call = T::clear;	fClear.call = T::clear;

	fConstruct.call = T::construct;	fConstruct = T::construct;
	fDestruct.call = T::destruct;	fDestruct = T::destruct;
	fFeed.call = T::feed;	fFeed = T::feed;
	CheckFunctions();	CheckFunctions();
	}	}
	virtual ~AnyCollectionProxy() { }	virtual ~AnyCollectionProxy() { }
	};	};

	#endif	#endif

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

	TGenCollectionStreamer.h	TGenCollectionStreamer.h

	// @(#)root/io:$Id: TGenCollectionStreamer.h 23122 2008-04-10 14:56:30Z rdm $	// @(#)root/io:$Id: TGenCollectionStreamer.h 36061 2010-10-04 16:05:51Z pca nal $
	// Author: Markus Frank 28/10/04	// Author: Markus Frank 28/10/04

	/*************************************************************************	/*************************************************************************
	* 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. *
	*************************************************************************/	*************************************************************************/
	#ifndef ROOT_TGenCollectionStreamer	#ifndef ROOT_TGenCollectionStreamer

	skipping to change at line 24	skipping to change at line 24
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// //	// //
	// TGenCollectionStreamer	// TGenCollectionStreamer
	//	//
	// Streamer around an arbitrary STL like container, which implements basic	// Streamer around an arbitrary STL like container, which implements basic
	// container functionality.	// container functionality.
	//	//
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#include "TGenCollectionProxy.h"	#include "TGenCollectionProxy.h"

		#include "TCollectionProxyFactory.h"

	class TGenCollectionStreamer : public TGenCollectionProxy {	class TGenCollectionStreamer : public TGenCollectionProxy {

	protected:	protected:
	void ReadMapHelper(StreamHelper i, Value v, Bool_t vsn3, TBuffer &b);	void ReadMapHelper(StreamHelper i, Value v, Bool_t vsn3, TBuffer &b);
	void ReadMap(int nElements, TBuffer &b);	void ReadMap(int nElements, TBuffer &b);
	void ReadPairFromMap(int nElements, TBuffer &b);	void ReadPairFromMap(int nElements, TBuffer &b);
	void ReadObjects(int nElements, TBuffer &b);	void ReadObjects(int nElements, TBuffer &b);
	void ReadPrimitives(int nElements, TBuffer &b);	void ReadPrimitives(int nElements, TBuffer &b);
	void WriteMap(int nElements, TBuffer &b);	void WriteMap(int nElements, TBuffer &b);
	void WriteObjects(int nElements, TBuffer &b);	void WriteObjects(int nElements, TBuffer &b);
	void WritePrimitives(int nElements, TBuffer &b);	void WritePrimitives(int nElements, TBuffer &b);


		// typedef void (TGenCollectionStreamer::*ReadBufferConv_t)(TBuffer &b, v
		oid obj, const TClass onfileClass);
		// ReadBufferConv_t fReadBufferConvFunc;

		typedef void (TGenCollectionStreamer::ReadBuffer_t)(TBuffer &b, void o
		bj);
		ReadBuffer_t fReadBufferFunc;

		template <typename basictype> void ReadBufferVectorPrimitives(TBuffer &b
		, void *obj);
		void ReadBufferVectorPrimitivesFloat16(TBuffer &b, void *obj);
		void ReadBufferVectorPrimitivesDouble32(TBuffer &b, void *obj);
		void ReadBufferDefault(TBuffer &b, void *obj);
		void ReadBufferGeneric(TBuffer &b, void *obj);

	public:	public:
	// Virtual copy constructor	// Virtual copy constructor
	virtual TVirtualCollectionProxy* Generate() const;	virtual TVirtualCollectionProxy* Generate() const;

	// Copy constructor	// Copy constructor
	TGenCollectionStreamer(const TGenCollectionStreamer& copy);	TGenCollectionStreamer(const TGenCollectionStreamer& copy);

	// Initializing constructor	// Initializing constructor
	TGenCollectionStreamer(Info_t typ, size_t iter_size);	TGenCollectionStreamer(Info_t typ, size_t iter_size);
	TGenCollectionStreamer(const ROOT::TCollectionProxyInfo &info, TClass *c l);	TGenCollectionStreamer(const ROOT::TCollectionProxyInfo &info, TClass *c l);

	skipping to change at line 61	skipping to change at line 74
	// Streamer I/O overload	// Streamer I/O overload
	virtual void Streamer(TBuffer &refBuffer);	virtual void Streamer(TBuffer &refBuffer);

	// Streamer I/O overload	// Streamer I/O overload
	virtual void StreamerAsMap(TBuffer &refBuffer);	virtual void StreamerAsMap(TBuffer &refBuffer);

	// Streamer I/O overload	// Streamer I/O overload
	virtual void Streamer(TBuffer &buff, void *pObj, int siz) {	virtual void Streamer(TBuffer &buff, void *pObj, int siz) {
	TGenCollectionProxy::Streamer(buff, pObj, siz);	TGenCollectionProxy::Streamer(buff, pObj, siz);
	}	}


		// Routine to read the content of the buffer into 'obj'.
		virtual void ReadBuffer(TBuffer &b, void obj, const TClass onfileClass
		);

		// Routine to read the content of the buffer into 'obj'.
		virtual void ReadBuffer(TBuffer &b, void *obj);
	};	};

	template <typename T>	template <typename T>
	struct AnyCollectionStreamer : public TGenCollectionStreamer {	struct AnyCollectionStreamer : public TGenCollectionStreamer {
	AnyCollectionStreamer()	AnyCollectionStreamer()
	: TGenCollectionStreamer(typeid(T::Cont_t),sizeof(T::Iter_t)) {	: TGenCollectionStreamer(typeid(T::Cont_t),sizeof(T::Iter_t)) {
	fValDiff = sizeof(T::Value_t);	fValDiff = sizeof(T::Value_t);
	fValOffset = T::value_offset();	fValOffset = T::value_offset();
	fSize.call = T::size;	fSize.call = T::size;
	fFirst.call = T::first;	fFirst.call = T::first;
	fNext.call = T::next;	fNext.call = T::next;
	fClear.call = T::clear;	fClear.call = T::clear;

	fResize.call = T::resize;	fResize = T::resize;
	fCollect.call = T::collect;	fCollect.call = T::collect;

	fConstruct.call = T::construct;	fConstruct = T::construct;
	fDestruct.call = T::destruct;	fDestruct = T::destruct;
	fFeed.call = T::feed;	fFeed = T::feed;
	CheckFunctions();	CheckFunctions();
	}	}
	virtual ~AnyCollectionStreamer() { }	virtual ~AnyCollectionStreamer() { }
	};	};

	// Forward declaration in the event of later seperation	// Forward declaration in the event of later seperation
	typedef TGenCollectionStreamer TGenMapStreamer;	typedef TGenCollectionStreamer TGenMapStreamer;

	#endif	#endif

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

	TGenericClassInfo.h	TGenericClassInfo.h

	// @(#)root/base:$Id: TGenericClassInfo.h 32337 2010-02-12 16:09:35Z pcanal $	// @(#)root/base:$Id: TGenericClassInfo.h 36954 2010-11-25 19:19:46Z pcanal $
	// Author: Philippe Canal 23/2/02	// Author: Philippe Canal 23/2/02

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2002, Rene Brun, Fons Rademakers and al. *	* Copyright (C) 1995-2002, Rene Brun, Fons Rademakers and al. *
	* 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
	TVirtualIsAProxy *fIsA;	TVirtualIsAProxy *fIsA;
	ShowMembersFunc_t fShowMembers;	ShowMembersFunc_t fShowMembers;
	Int_t fVersion;	Int_t fVersion;
	NewFunc_t fNew;	NewFunc_t fNew;
	NewArrFunc_t fNewArray;	NewArrFunc_t fNewArray;
	DelFunc_t fDelete;	DelFunc_t fDelete;
	DelArrFunc_t fDeleteArray;	DelArrFunc_t fDeleteArray;
	DesFunc_t fDestructor;	DesFunc_t fDestructor;
	DirAutoAdd_t fDirAutoAdd;	DirAutoAdd_t fDirAutoAdd;
	TClassStreamer *fStreamer;	TClassStreamer *fStreamer;

		ClassStreamerFunc_t fStreamerFunc;
	TVirtualCollectionProxy *fCollectionProxy;	TVirtualCollectionProxy *fCollectionProxy;
	Int_t fSizeof;	Int_t fSizeof;
	TCollectionProxyInfo *fCollectionProxyInfo;	TCollectionProxyInfo *fCollectionProxyInfo;
	TCollectionProxyInfo *fCollectionStreamerInfo;	TCollectionProxyInfo *fCollectionStreamerInfo;

	std::vector<TSchemaHelper> fReadRules;	std::vector<ROOT::TSchemaHelper> fReadRules;
	std::vector<TSchemaHelper> fReadRawRules;	std::vector<ROOT::TSchemaHelper> fReadRawRules;

	public:	public:
	TGenericClassInfo(const char *fullClassname,	TGenericClassInfo(const char *fullClassname,
	const char *declFileName, Int_t declFileLine,	const char *declFileName, Int_t declFileLine,
	const type_info &info, const TInitBehavior *action,	const type_info &info, const TInitBehavior *action,
	ShowMembersFunc_t showmembers, VoidFuncPtr_t diction ary,	ShowMembersFunc_t showmembers, VoidFuncPtr_t diction ary,
	TVirtualIsAProxy *isa, Int_t pragmabits, Int_t sizof );	TVirtualIsAProxy *isa, Int_t pragmabits, Int_t sizof );

	TGenericClassInfo(const char *fullClassname, Int_t version,	TGenericClassInfo(const char *fullClassname, Int_t version,
	const char *declFileName, Int_t declFileLine,	const char *declFileName, Int_t declFileLine,

	skipping to change at line 109	skipping to change at line 110
	DelFunc_t GetDelete() const;	DelFunc_t GetDelete() const;
	DelArrFunc_t GetDeleteArray() const;	DelArrFunc_t GetDeleteArray() const;
	DesFunc_t GetDestructor() const;	DesFunc_t GetDestructor() const;
	DirAutoAdd_t GetDirectoryAutoAdd() const;	DirAutoAdd_t GetDirectoryAutoAdd() const;
	const char *GetImplFileName();	const char *GetImplFileName();
	Int_t GetImplFileLine();	Int_t GetImplFileLine();
	const type_info &GetInfo() const;	const type_info &GetInfo() const;
	TVirtualIsAProxy *GetIsA() const;	TVirtualIsAProxy *GetIsA() const;
	NewFunc_t GetNew() const;	NewFunc_t GetNew() const;
	NewArrFunc_t GetNewArray() const;	NewArrFunc_t GetNewArray() const;

	const std::vector<TSchemaHelper> &GetReadRawRules() const;	const std::vector<ROOT::TSchemaHelper> &GetReadRawRules() const;
	const std::vector<TSchemaHelper> &GetReadRules() const;	const std::vector<ROOT::TSchemaHelper> &GetReadRules() const;
	ShowMembersFunc_t GetShowMembers() const;	ShowMembersFunc_t GetShowMembers() const;
	Int_t GetVersion() const;	Int_t GetVersion() const;

	TClass IsA(const void obj);	TClass IsA(const void obj);

	Short_t AdoptStreamer(TClassStreamer*);	Short_t AdoptStreamer(TClassStreamer*);
	Short_t AdoptCollectionProxy(TVirtualCollec tionProxy*);	Short_t AdoptCollectionProxy(TVirtualCollec tionProxy*);
	void AdoptCollectionProxyInfo(TCollectio nProxyInfo*);	void AdoptCollectionProxyInfo(TCollectio nProxyInfo*);
	void AdoptCollectionStreamerInfo(TCollec tionProxyInfo*);	void AdoptCollectionStreamerInfo(TCollec tionProxyInfo*);
	Int_t SetDeclFile(const char *file, Int_t line);	Int_t SetDeclFile(const char *file, Int_t line);
	void SetDelete(DelFunc_t deleteFunc);	void SetDelete(DelFunc_t deleteFunc);
	void SetDeleteArray(DelArrFunc_t deleteA rrayFunc);	void SetDeleteArray(DelArrFunc_t deleteA rrayFunc);
	void SetDestructor(DesFunc_t destructorF unc);	void SetDestructor(DesFunc_t destructorF unc);
	void SetDirectoryAutoAdd(DirAutoAdd_t di rAutoAdd);	void SetDirectoryAutoAdd(DirAutoAdd_t di rAutoAdd);
	void SetFromTemplate();	void SetFromTemplate();
	Int_t SetImplFile(const char *file, Int_t line);	Int_t SetImplFile(const char *file, Int_t line);
	void SetNew(NewFunc_t newFunc);	void SetNew(NewFunc_t newFunc);
	void SetNewArray(NewArrFunc_t newArrayFu nc);	void SetNewArray(NewArrFunc_t newArrayFu nc);

	void SetReadRawRules( const std::vector<	void SetReadRawRules( const std::vector<
	TSchemaHelper>& rules );	ROOT::TSchemaHelper>& rules );
	void SetReadRules( const std::vector<TSc	void SetReadRules( const std::vector<ROO
	hemaHelper>& rules );	T::TSchemaHelper>& rules );
	Short_t SetStreamer(ClassStreamerFunc_t);	Short_t SetStreamer(ClassStreamerFunc_t);

		void SetStreamerFunc(ClassStreamerFunc_t );
	Short_t SetVersion(Short_t version);	Short_t SetVersion(Short_t version);

	// protected:	// protected:
	private:	private:

	void CreateRuleSet( std::vector<TSchemaHelper>& vect, Bool_t ProcessR eadRules );	void CreateRuleSet( std::vector<ROOT::TSchemaHelper>& vect, Bool_t Pr ocessReadRules );
	TGenericClassInfo(const TGenericClassInfo&); // Not implemented	TGenericClassInfo(const TGenericClassInfo&); // Not implemented
	TGenericClassInfo& operator=(const TGenericClassInfo&); // Not implem ented	TGenericClassInfo& operator=(const TGenericClassInfo&); // Not implem ented

	private:	private:
	TGenericClassInfo();	TGenericClassInfo();

	};	};

	}	}


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

	TGraph2D.h	TGraph2D.h

	skipping to change at line 94	skipping to change at line 94
	TGraph2D(Int_t n, Double_t x, Double_t y, Double_t *z);	TGraph2D(Int_t n, Double_t x, Double_t y, Double_t *z);
	TGraph2D(TH2 *h2);	TGraph2D(TH2 *h2);
	TGraph2D(const char name, const char title, Int_t n, Double_t x, Doub le_t y, Double_t *z);	TGraph2D(const char name, const char title, Int_t n, Double_t x, Doub le_t y, Double_t *z);
	TGraph2D(const char filename, const char format="%lg %lg %lg", Option_ t *option="");	TGraph2D(const char filename, const char format="%lg %lg %lg", Option_ t *option="");
	TGraph2D(const TGraph2D &);	TGraph2D(const TGraph2D &);

	virtual ~TGraph2D();	virtual ~TGraph2D();

	TGraph2D& operator=(const TGraph2D &);	TGraph2D& operator=(const TGraph2D &);


	virtual void Clear(Option_t *option="");	virtual void Clear(Option_t *option="");
	virtual void DirectoryAutoAdd(TDirectory *);	virtual void DirectoryAutoAdd(TDirectory *);
	Int_t DistancetoPrimitive(Int_t px, Int_t py);	Int_t DistancetoPrimitive(Int_t px, Int_t py);
	virtual void Draw(Option_t *option="");	virtual void Draw(Option_t *option="");
	void ExecuteEvent(Int_t event, Int_t px, Int_t py);	void ExecuteEvent(Int_t event, Int_t px, Int_t py);
	virtual TObject FindObject(const char name) const;	virtual TObject FindObject(const char name) const;
	virtual TObject FindObject(const TObject obj) const;	virtual TObject FindObject(const TObject obj) const;
	virtual TFitResultPtr Fit(const char formula ,Option_t option="" ,Opti on_t goption=""); // MENU*	virtual TFitResultPtr Fit(const char formula ,Option_t option="" ,Opti on_t goption=""); // MENU*
	virtual TFitResultPtr Fit(TF2 f2 ,Option_t option="" ,Option_t goptio n=""); // MENU*	virtual TFitResultPtr Fit(TF2 f2 ,Option_t option="" ,Option_t goptio n=""); // MENU*

	virtual void FitPanel(); // MENU	virtual void FitPanel(); // MENU
	TList *GetContourList(Double_t contour);	TList *GetContourList(Double_t contour);
	TDirectory *GetDirectory() const {return fDirectory;}	TDirectory *GetDirectory() const {return fDirectory;}
	Int_t GetNpx() const {return fNpx;}	Int_t GetNpx() const {return fNpx;}
	Int_t GetNpy() const {return fNpy;}	Int_t GetNpy() const {return fNpy;}
	TH2D GetHistogram(Option_t option="");	TH2D GetHistogram(Option_t option="");
	TList *GetListOfFunctions() const { return fFunctions; }	TList *GetListOfFunctions() const { return fFunctions; }
	virtual Double_t GetErrorX(Int_t bin) const;	virtual Double_t GetErrorX(Int_t bin) const;
	virtual Double_t GetErrorY(Int_t bin) const;	virtual Double_t GetErrorY(Int_t bin) const;
	virtual Double_t GetErrorZ(Int_t bin) const;	virtual Double_t GetErrorZ(Int_t bin) const;
	Double_t GetMargin() const {return fMargin;}	Double_t GetMargin() const {return fMargin;}
	TAxis *GetXaxis() const ;	TAxis *GetXaxis() const ;
	TAxis *GetYaxis() const ;	TAxis *GetYaxis() const ;
	TAxis *GetZaxis() const ;	TAxis *GetZaxis() const ;
	Int_t GetN() const {return fNpoints;}	Int_t GetN() const {return fNpoints;}
	Double_t *GetX() const {return fX;}	Double_t *GetX() const {return fX;}
	Double_t *GetY() const {return fY;}	Double_t *GetY() const {return fY;}
	Double_t *GetZ() const {return fZ;}	Double_t *GetZ() const {return fZ;}
	virtual Double_t *GetEX() const {return 0;}	virtual Double_t *GetEX() const {return 0;}
	virtual Double_t *GetEY() const {return 0;}	virtual Double_t *GetEY() const {return 0;}
	virtual Double_t *GetEZ() const {return 0;}	virtual Double_t *GetEZ() const {return 0;}
	Double_t GetXmax() const;	Double_t GetXmax() const;
	Double_t GetXmin() const;	Double_t GetXmin() const;
	Double_t GetYmax() const;	Double_t GetYmax() const;
	Double_t GetYmin() const;	Double_t GetYmin() const;
	Double_t GetZmax() const;	Double_t GetZmax() const;
	Double_t GetZmin() const;	Double_t GetZmin() const;
	Double_t Interpolate(Double_t x, Double_t y);	virtual Double_t GetXmaxE() const {return GetXmax();};
	void Paint(Option_t *option="");	virtual Double_t GetXminE() const {return GetXmin();};
	TH1 Project(Option_t option="x") const; // MENU	virtual Double_t GetYmaxE() const {return GetYmax();};
	Int_t RemovePoint(Int_t ipoint); // MENU	virtual Double_t GetYminE() const {return GetYmin();};
	virtual void SavePrimitive(ostream &out, Option_t *option = "");	virtual Double_t GetZmaxE() const {return GetZmax();};
	virtual void Set(Int_t n);	virtual Double_t GetZminE() const {return GetZmin();};
	virtual void SetDirectory(TDirectory *dir);	Double_t Interpolate(Double_t x, Double_t y);
	virtual void SetHistogram(TH2 *h);	void Paint(Option_t *option="");
	void SetMargin(Double_t m=0.1); // MENU	TH1 Project(Option_t option="x") const; // MENU
	void SetMarginBinsContent(Double_t z=0.); // MENU	Int_t RemovePoint(Int_t ipoint); // MENU
	void SetMaximum(Double_t maximum=-1111); // MENU	virtual void SavePrimitive(ostream &out, Option_t *option = "")
	void SetMinimum(Double_t minimum=-1111); // MENU	;
	void SetMaxIter(Int_t n=100000) {fMaxIter = n;} // MENU	virtual void Set(Int_t n);
	virtual void SetName(const char name); // MENU*	virtual void SetDirectory(TDirectory *dir);
	virtual void SetNameTitle(const char name, const char title);	virtual void SetHistogram(TH2 *h);
	void SetNpx(Int_t npx=40); // MENU	void SetMargin(Double_t m=0.1); // MENU
	void SetNpy(Int_t npx=40); // MENU	void SetMarginBinsContent(Double_t z=0.); // MENU
	virtual void SetPoint(Int_t point, Double_t x, Double_t y, Double_t	void SetMaximum(Double_t maximum=-1111); // MENU
	z); // MENU	void SetMinimum(Double_t minimum=-1111); // MENU
	virtual void SetTitle(const char title=""); // MENU*	void SetMaxIter(Int_t n=100000) {fMaxIter = n;} // *MEN
		U*
		virtual void SetName(const char name); // MENU*
		virtual void SetNameTitle(const char name, const char title);
		void SetNpx(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 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[i],y[i],z[i] points with 3-d graphics including Delaunay triangulation
	};	};

	#endif	#endif

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

	TGraph2DErrors.h	TGraph2DErrors.h

	skipping to change at line 48	skipping to change at line 48

	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="");
	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 GetXminE() const;
		Double_t GetYmaxE() const;
		Double_t GetYminE() const;
		Double_t GetZmaxE() const;
		Double_t GetZminE() const;
	virtual void Set(Int_t n);	virtual void Set(Int_t n);
	virtual void SetPoint(Int_t i, Double_t x, Double_t y, Double_t z);	virtual void SetPoint(Int_t i, Double_t x, Double_t y, Double_t z);
	virtual void SetPointError(Int_t i, Double_t ex, Double_t ey, Double_ t ez);	virtual void SetPointError(Int_t i, Double_t ex, Double_t ey, Double_ t ez);

	ClassDef(TGraph2DErrors,1) //A 2D graph with error bars	ClassDef(TGraph2DErrors,1) //A 2D graph with error bars
	};	};

	#endif	#endif

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

	TGraph2DPainter.h	TGraph2DPainter.h

	skipping to change at line 40	skipping to change at line 40

	class TGraph2DPainter : public TObject {	class TGraph2DPainter : public TObject {

	protected:	protected:

	Double_t *fX; //!Pointer to fGraph2D->fX	Double_t *fX; //!Pointer to fGraph2D->fX
	Double_t *fY; //!Pointer to fGraph2D->fY	Double_t *fY; //!Pointer to fGraph2D->fY
	Double_t *fZ; //!Pointer to fGraph2D->fZ	Double_t *fZ; //!Pointer to fGraph2D->fZ
	Double_t *fXN; //!Pointer to fDelaunay->fXN	Double_t *fXN; //!Pointer to fDelaunay->fXN
	Double_t *fYN; //!Pointer to fDelaunay->fYN	Double_t *fYN; //!Pointer to fDelaunay->fYN

		Double_t *fEX; //!Pointer to fGraph2D->fXE
		Double_t *fEY; //!Pointer to fGraph2D->fYE
		Double_t *fEZ; //!Pointer to fGraph2D->fZE
	Double_t fXNmin; //!Equal to fDelaunay->fXNmin	Double_t fXNmin; //!Equal to fDelaunay->fXNmin
	Double_t fXNmax; //!Equal to fDelaunay->fXNmax	Double_t fXNmax; //!Equal to fDelaunay->fXNmax
	Double_t fYNmin; //!Equal to fDelaunay->fYNmin	Double_t fYNmin; //!Equal to fDelaunay->fYNmin
	Double_t fYNmax; //!Equal to fDelaunay->fYNmax	Double_t fYNmax; //!Equal to fDelaunay->fYNmax
	Double_t fXmin; //!	Double_t fXmin; //!
	Double_t fXmax; //!	Double_t fXmax; //!
	Double_t fYmin; //! fGraph2D->fHistogram limits	Double_t fYmin; //! fGraph2D->fHistogram limits
	Double_t fYmax; //!	Double_t fYmax; //!
	Double_t fZmin; //!	Double_t fZmin; //!
	Double_t fZmax; //!	Double_t fZmax; //!

	skipping to change at line 72	skipping to change at line 75

	public:	public:

	TGraph2DPainter();	TGraph2DPainter();
	TGraph2DPainter(TGraphDelaunay *gd);	TGraph2DPainter(TGraphDelaunay *gd);

	virtual ~TGraph2DPainter();	virtual ~TGraph2DPainter();

	TList *GetContourList(Double_t contour);	TList *GetContourList(Double_t contour);
	void Paint(Option_t *option);	void Paint(Option_t *option);

	void PaintTriangles(Option_t *option);	void PaintContour(Option_t *option);
		void PaintErrors(Option_t *option);
	void PaintPolyMarker(Option_t *option);	void PaintPolyMarker(Option_t *option);
	void PaintPolyLine(Option_t *option);	void PaintPolyLine(Option_t *option);

	void PaintContour(Option_t *option);	void PaintTriangles(Option_t *option);

	ClassDef(TGraph2DPainter,0) // TGraph2D painter	ClassDef(TGraph2DPainter,0) // TGraph2D painter
	};	};

	#endif	#endif

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

	THnSparse.h	THnSparse.h

	// @(#)root/hist:$Id: THnSparse.h 32836 2010-03-30 14:27:57Z moneta $	// @(#)root/hist:$Id: THnSparse.h 36894 2010-11-24 11:04:47Z moneta $
	// Author: Axel Naumann (2007-09-11)	// Author: Axel Naumann (2007-09-11)

	/*************************************************************************	/*************************************************************************
	* 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 34	skipping to change at line 34
	#endif	#endif
	#ifndef ROOT_TNamed	#ifndef ROOT_TNamed
	#include "TNamed.h"	#include "TNamed.h"
	#endif	#endif
	#ifndef ROOT_TObjArray	#ifndef ROOT_TObjArray
	#include "TObjArray.h"	#include "TObjArray.h"
	#endif	#endif
	#ifndef ROOT_TArrayD	#ifndef ROOT_TArrayD
	#include "TArrayD.h"	#include "TArrayD.h"
	#endif	#endif

		#ifndef ROOT_TFitResultPtr
		#include "TFitResultPtr.h"
		#endif

	// needed only for template instantiations of THnSparseT:	// needed only for template instantiations of THnSparseT:
	#ifndef ROOT_TArrayF	#ifndef ROOT_TArrayF
	#include "TArrayF.h"	#include "TArrayF.h"
	#endif	#endif
	#ifndef ROOT_TArrayL	#ifndef ROOT_TArrayL
	#include "TArrayL.h"	#include "TArrayL.h"
	#endif	#endif
	#ifndef ROOT_TArrayI	#ifndef ROOT_TArrayI
	#include "TArrayI.h"	#include "TArrayI.h"
	#endif	#endif
	#ifndef ROOT_TArrayS	#ifndef ROOT_TArrayS
	#include "TArrayS.h"	#include "TArrayS.h"
	#endif	#endif
	#ifndef ROOT_TArrayC	#ifndef ROOT_TArrayC
	#include "TArrayC.h"	#include "TArrayC.h"
	#endif	#endif

	class TAxis;	class TAxis;
	class TCollection;	class TCollection;

	class TFitResultPtr;
	class TH1;	class TH1;
	class TH1D;	class TH1D;
	class TH2D;	class TH2D;
	class TH3D;	class TH3D;
	class TF1;	class TF1;


	#include "TFitResultPtr.h"

	class THnSparseArrayChunk: public TObject {	class THnSparseArrayChunk: public TObject {
	private:	private:

	THnSparseArrayChunk(const THnSparseArrayChunk&); // Not implemented	THnSparseArrayChunk(const THnSparseArrayChunk&); // Not implemented
	THnSparseArrayChunk& operator=(const THnSparseArrayChunk&); // Not imple mented	THnSparseArrayChunk& operator=(const THnSparseArrayChunk&); // Not imple mented

	public:	public:
	THnSparseArrayChunk():	THnSparseArrayChunk():
	fCoordinateAllocationSize(-1), fSingleCoordinateSize(0), fCoordinates Size(0), fCoordinates(0),	fCoordinateAllocationSize(-1), fSingleCoordinateSize(0), fCoordinates Size(0), fCoordinates(0),
	fContent(0), fSumw2(0) {}	fContent(0), fSumw2(0) {}

	skipping to change at line 167	skipping to change at line 167
	THnSparse* CloneEmpty(const char* name, const char* title,	THnSparse* CloneEmpty(const char* name, const char* title,
	const TObjArray* axes, Int_t chunksize,	const TObjArray* axes, Int_t chunksize,
	Bool_t keepTargetAxis) const;	Bool_t keepTargetAxis) const;

	Bool_t CheckConsistency(const THnSparse h, const char tag) const;	Bool_t CheckConsistency(const THnSparse h, const char tag) const;
	Bool_t IsInRange(Int_t *coord) const;	Bool_t IsInRange(Int_t *coord) const;
	TH1* CreateHist(const char* name, const char* title,	TH1* CreateHist(const char* name, const char* title,
	const TObjArray* axes, Bool_t keepTargetAxis) const;	const TObjArray* axes, Bool_t keepTargetAxis) const;
	TObject* ProjectionAny(Int_t ndim, const Int_t* dim,	TObject* ProjectionAny(Int_t ndim, const Int_t* dim,
	Bool_t wantSparse, Option_t* option = "") const;	Bool_t wantSparse, Option_t* option = "") const;

		Bool_t PrintBin(Long64_t idx, Int_t* coord, Option_t* options) const;
		void AddInternal(const THnSparse* h, Double_t c, Bool_t rebinned);

	public:	public:
	virtual ~THnSparse();	virtual ~THnSparse();

	static THnSparse* CreateSparse(const char* name, const char* title,	static THnSparse* CreateSparse(const char* name, const char* title,
	const TH1* h1, Int_t ChunkSize = 1024 * 1 6);	const TH1* h1, Int_t ChunkSize = 1024 * 1 6);

	Int_t GetNChunks() const { return fBinContent.GetEntriesFast(); }	Int_t GetNChunks() const { return fBinContent.GetEntriesFast(); }
	TObjArray* GetListOfAxes() { return &fAxes; }	TObjArray* GetListOfAxes() { return &fAxes; }
	TAxis* GetAxis(Int_t dim) const { return (TAxis*)fAxes[dim]; }	TAxis* GetAxis(Int_t dim) const { return (TAxis*)fAxes[dim]; }

	skipping to change at line 234	skipping to change at line 236

	Double_t GetSparseFractionBins() const;	Double_t GetSparseFractionBins() const;
	Double_t GetSparseFractionMem() const;	Double_t GetSparseFractionMem() const;

	Double_t GetSumw() const { return fTsumw; }	Double_t GetSumw() const { return fTsumw; }
	Double_t GetSumw2() const { return fTsumw2; }	Double_t GetSumw2() const { return fTsumw2; }
	Double_t GetSumwx(Int_t dim) const { return fTsumwx[dim]; }	Double_t GetSumwx(Int_t dim) const { return fTsumwx[dim]; }
	Double_t GetSumwx2(Int_t dim) const { return fTsumwx2[dim]; }	Double_t GetSumwx2(Int_t dim) const { return fTsumwx2[dim]; }

	TH1D* Projection(Int_t xDim, Option_t* option = "") const;	TH1D* Projection(Int_t xDim, Option_t* option = "") const;

	TH2D* Projection(Int_t xDim, Int_t yDim,	TH2D* Projection(Int_t yDim, Int_t xDim,
	Option_t* option = "") const;	Option_t* option = "") const;
	TH3D* Projection(Int_t xDim, Int_t yDim, Int_t zDim,	TH3D* Projection(Int_t xDim, Int_t yDim, Int_t zDim,
	Option_t* option = "") const;	Option_t* option = "") const;
	THnSparse* Projection(Int_t ndim, const Int_t* dim,	THnSparse* Projection(Int_t ndim, const Int_t* dim,
	Option_t* option = "") const;	Option_t* option = "") const;

	THnSparse* Rebin(Int_t group) const;	THnSparse* Rebin(Int_t group) const;
	THnSparse* Rebin(const Int_t* group) const;	THnSparse* Rebin(const Int_t* group) const;

	Long64_t Merge(TCollection* list);	Long64_t Merge(TCollection* list);

	skipping to change at line 260	skipping to change at line 262
	void Divide(const THnSparse* h);	void Divide(const THnSparse* h);
	void Divide(const THnSparse* h1, const THnSparse* h2, Double_t c1 = 1., Double_t c2 = 1., Option_t* option="");	void Divide(const THnSparse* h1, const THnSparse* h2, Double_t c1 = 1., Double_t c2 = 1., Option_t* option="");
	void RebinnedAdd(const THnSparse* h, Double_t c=1.);	void RebinnedAdd(const THnSparse* h, Double_t c=1.);

	void Reset(Option_t* option = "");	void Reset(Option_t* option = "");
	void Sumw2();	void Sumw2();

	Double_t ComputeIntegral();	Double_t ComputeIntegral();
	void GetRandom(Double_t *rand, Bool_t subBinRandom = kTRUE);	void GetRandom(Double_t *rand, Bool_t subBinRandom = kTRUE);


		void Print(Option_t* option = "") const;
		void PrintEntries(Long64_t from = 0, Long64_t howmany = -1, Option_t* op
		tions = 0) const;
		void PrintBin(Int_t* coord, Option_t* options) const {
		PrintBin(-1, coord, options);
		}
		void PrintBin(Long64_t idx, Option_t* options) const;

	//void Draw(Option_t* option = "");	//void Draw(Option_t* option = "");

	ClassDef(THnSparse, 2); // Interfaces of sparse n-dimensional histogram	ClassDef(THnSparse, 2); // Interfaces of sparse n-dimensional histogram
	};	};

	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	//	//
	// Templated implementation of the abstract base THnSparse.	// Templated implementation of the abstract base THnSparse.
	// All functionality and the interfaces to be used are in THnSparse!	// All functionality and the interfaces to be used are in THnSparse!
	//	//

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

	TKDE.h	TKDE.h

	// @(#)root/hist:$Id: TKDE.h 35847 2010-09-28 15:40:18Z moneta $	// @(#)root/hist:$Id: TKDE.h 37543 2010-12-11 14:14:05Z moneta $
	// Authors: Bartolomeu Rabacal 07/2010	// Authors: Bartolomeu Rabacal 07/2010
	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 , LCG ROOT MathLib Team *	* Copyright (c) 2006 , LCG ROOT MathLib Team *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/
	// Header file for TKDE	// Header file for TKDE

	#ifndef ROOT_TKDE	#ifndef ROOT_TKDE
	#define ROOT_TKDE	#define ROOT_TKDE

	#ifndef ROOT_Math_WrappedFunction	#ifndef ROOT_Math_WrappedFunction

	#include "Math/WrappedFunction.h"	#include "Math/WrappedFunction.h"
	#endif	#endif


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

		#ifndef ROOT_Math_Math
	#include "Math/Math.h"	#include "Math/Math.h"

		#endif

		//#include "TF1.h"
		class TGraphErrors;
		class TF1;

	/*	/*

	Kernel Density Estimation class. The three main references are (1) "Scot	Kernel Density Estimation class. The three main references are (1) "Scot
	t DW, Multivariate Density Estimation. Theory, Practice and Visualization.	t DW, Multivariate Density Estimation.
	New York: Wiley", (2) "Jann Ben - ETH Zurich, Switzerland -, Univariate ker	Theory, Practice and Visualization. New York: Wiley", (2) "Jann Ben - ETH Z
	nel density estimation document for KDENS: Stata module for univariate kern	urich, Switzerland -, Univariate kernel density estimation document for KDE
	el density estimation." and (3) "Hardle W, Muller M, Sperlich S, Werwatz A,	NS: Stata module for univariate kernel density estimation." and (3) "Hardle
	Nonparametric and Semiparametric Models. Springer."	W, Muller M, Sperlich S, Werwatz A, Nonparametric and Semiparametric Model
		s. Springer."
	The algorithm is briefly described in (4) "Cranmer KS, Kernel Estimation in High-Energy	The algorithm is briefly described in (4) "Cranmer KS, Kernel Estimation in High-Energy

	Physics. Computer Physics Communications 136:198-207,2001" - e-Print Arc	Physics. Computer Physics Communications 136:198-207,2001" - e-Print Archiv
	hive: hep ex/0011057.	e: hep ex/0011057.
	A binned version is also implemented to address the performance issue du	A binned version is also implemented to address the performance issue du
	e to its data	e to its data size dependence.
	size dependance.
	*/	*/
	class TKDE : public TNamed {	class TKDE : public TNamed {
	public:	public:

	enum EKernelType { // Kernel function type option	enum EKernelType { // Kernel function type option
	kGaussian,	kGaussian,
	kEpanechnikov,	kEpanechnikov,
	kBiweight,	kBiweight,
	kCosineArch,	kCosineArch,
	kUserDefined, // Internal use only for the class's template construct or	kUserDefined, // Internal use only for the class's template construct or

	skipping to change at line 64	skipping to change at line 72
	kMirrorLeftAsymRight,	kMirrorLeftAsymRight,
	kMirrorAsymBoth	kMirrorAsymBoth
	};	};

	enum EBinning{ // Data binning option	enum EBinning{ // Data binning option
	kUnbinned,	kUnbinned,
	kRelaxedBinning, // The algorithm is allowed to use binning if the da ta is large enough	kRelaxedBinning, // The algorithm is allowed to use binning if the da ta is large enough
	kForcedBinning	kForcedBinning
	};	};


	explicit TKDE(UInt_t events=0, const Double_t* data=0, Double_t xMin = 0 .0, Double_t xMax = 0.0, Option_t* option = "KernelType:Gaussian;Iteration: Adaptive;Mirror:noMirror;Binning:RelaxedBinning", Double_t rho = 1.0);	explicit TKDE(UInt_t events = 0, const Double_t* data = 0, Double_t xMin = 0.0, Double_t xMax = 0.0, const Option_t* option = "KernelType:Gaussian; Iteration:Adaptive;Mirror:noMirror;Binning:RelaxedBinning", Double_t rho = 1.0);

	template<class KernelFunction>	template<class KernelFunction>

	TKDE(const char * name, const KernelFunction& kernfunc, UInt_t events, c onst Double_t* data, Double_t xMin = 0.0, Double_t xMax = 0.0, Option_t* op tion = "KernelType:UserDefined;Iteration:Adaptive;Mirror:noMirror;Binning:R elaxedBinning", Double_t rho = 1.0) {	TKDE(const Char_t* /name/, const KernelFunction& kernfunc, UInt_t even ts, const Double_t* data, Double_t xMin = 0.0, Double_t xMax = 0.0, const O ption_t* option = "KernelType:UserDefined;Iteration:Adaptive;Mirror:noMirro r;Binning:RelaxedBinning", Double_t rho = 1.0) {
	Instantiate(new ROOT::Math::WrappedFunction<const KernelFunction&>(ke rnfunc), events, data, xMin, xMax, option, rho);	Instantiate(new ROOT::Math::WrappedFunction<const KernelFunction&>(ke rnfunc), events, data, xMin, xMax, option, rho);
	}	}

	virtual ~TKDE();	virtual ~TKDE();

	void Fill(Double_t data);	void Fill(Double_t data);
	void SetKernelType(EKernelType kern);	void SetKernelType(EKernelType kern);
	void SetIteration(EIteration iter);	void SetIteration(EIteration iter);
	void SetMirror(EMirror mir);	void SetMirror(EMirror mir);
	void SetBinning(EBinning);	void SetBinning(EBinning);
	void SetNBins(UInt_t nbins);	void SetNBins(UInt_t nbins);
	void SetUseBinsNEvents(UInt_t nEvents);	void SetUseBinsNEvents(UInt_t nEvents);

	void SetAdaptiveTuneFactor(Double_t rho);	void SetTuneFactor(Double_t rho);
	void SetRange(Double_t xMin, Double_t xMax); // By default computed from the data	void SetRange(Double_t xMin, Double_t xMax); // By default computed from the data


		virtual void Draw(const Option_t* option = "");

	Double_t operator()(Double_t x) const;	Double_t operator()(Double_t x) const;

	Double_t operator()(const Double_t* x, const Double_t* p=0) const; // n eeded for creating TF1	Double_t operator()(const Double_t* x, const Double_t* p=0) const; // N eeded for creating TF1

	Double_t GetValue(Double_t x) const { return (*this)(x); }	Double_t GetValue(Double_t x) const { return (*this)(x); }
	Double_t GetError(Double_t x) const;	Double_t GetError(Double_t x) const;

	Double_t GetBias(Double_t x) const;	Double_t GetBias(Double_t x) const;
	Double_t GetMean() const;	Double_t GetMean() const;
	Double_t GetSigma() const;	Double_t GetSigma() const;

		Double_t GetRAMISE() const;

	Double_t GetFixedWeight() const;	Double_t GetFixedWeight() const;


	TH1D* GetHistogram(UInt_t nbins = 100, Double_t xMin = 1.0, Double_t xMa
	x = 0.0);

	TF1* GetFunction(UInt_t npx = 100, Double_t xMin = 1.0, Double_t xMax = 0.0);	TF1* GetFunction(UInt_t npx = 100, Double_t xMin = 1.0, Double_t xMax = 0.0);
	TF1* GetUpperFunction(Double_t confidenceLevel = 0.95, UInt_t npx = 100, Double_t xMin = 1.0, Double_t xMax = 0.0);	TF1* GetUpperFunction(Double_t confidenceLevel = 0.95, UInt_t npx = 100, Double_t xMin = 1.0, Double_t xMax = 0.0);
	TF1* GetLowerFunction(Double_t confidenceLevel = 0.95, UInt_t npx = 100, Double_t xMin = 1.0, Double_t xMax = 0.0);	TF1* GetLowerFunction(Double_t confidenceLevel = 0.95, UInt_t npx = 100, Double_t xMin = 1.0, Double_t xMax = 0.0);
	TF1* GetApproximateBias(UInt_t npx = 100, Double_t xMin = 1.0, Double_t xMax = 0.0);	TF1* GetApproximateBias(UInt_t npx = 100, Double_t xMin = 1.0, Double_t xMax = 0.0);

		TGraphErrors * GetGraphWithErrors(UInt_t npx = 100, Double_t xMin = 1.0,
		Double_t xMax = 0.0);

		// get the drawn object to chanage settings
		// These objects are managed by TKDE and should not be deleted by the us
		er
		TF1 * GetDrawnFunction() { return fPDF;}
		TF1 * GetDrawnUpperFunction() { return fUpperPDF;}
		TF1 * GetDrawnLowerFunction() { return fLowerPDF;}
		TGraphErrors * GetDrawnGraph() { return fGraph;}

	const Double_t * GetAdaptiveWeights() const;	const Double_t * GetAdaptiveWeights() const;

	private:	private:


	static const Double_t _2_PI_ROOT_INV; // (2TMath::Pi())*-0.5
	static const Double_t PI; // TMath::Pi()
	static const Double_t PI_OVER2; // TMath::PiOver2()
	static const Double_t PI_OVER4; // TMath::PiOver4()

	TKDE(TKDE& kde); // Disallowed copy constructor	TKDE(TKDE& kde); // Disallowed copy constructor
	TKDE operator=(TKDE& kde); // Disallowed assign operator	TKDE operator=(TKDE& kde); // Disallowed assign operator

	typedef ROOT::Math::IBaseFunctionOneDim* KernelFunction_Ptr;	typedef ROOT::Math::IBaseFunctionOneDim* KernelFunction_Ptr;
	KernelFunction_Ptr fKernelFunction;	KernelFunction_Ptr fKernelFunction;

	class TKernel;	class TKernel;
	friend class TKernel;	friend class TKernel;

	TKernel* fKernel;	TKernel* fKernel;

	std::vector<Double_t> fData; // Data events	std::vector<Double_t> fData; // Data events
	std::vector<Double_t> fEvents; // Original data storage	std::vector<Double_t> fEvents; // Original data storage

	TF1* fPDF; // Output Kernel Density Estimation PDF function	TF1* fPDF; // Output Kernel Density Estimation PDF function
	TF1* fUpperPDF; // Output Kernel Density Estimation upper confide nce interval PDF function	TF1* fUpperPDF; // Output Kernel Density Estimation upper confide nce interval PDF function
	TF1* fLowerPDF; // Output Kernel Density Estimation lower confide nce interval PDF function	TF1* fLowerPDF; // Output Kernel Density Estimation lower confide nce interval PDF function
	TF1* fApproximateBias; // Output Kernel Density Estimation approximate b ias	TF1* fApproximateBias; // Output Kernel Density Estimation approximate b ias

		TGraphErrors* fGraph; // Graph with the errors
	TH1D* fHistogram; // Output data histogram

	EKernelType fKernelType;	EKernelType fKernelType;
	EIteration fIteration;	EIteration fIteration;
	EMirror fMirror;	EMirror fMirror;
	EBinning fBinning;	EBinning fBinning;

	Bool_t fUseMirroring, fMirrorLeft, fMirrorRight, fAsymLeft, fAsymRight;	Bool_t fUseMirroring, fMirrorLeft, fMirrorRight, fAsymLeft, fAsymRight;
	Bool_t fUseBins;	Bool_t fUseBins;
	Bool_t fNewData; // flag to control when new data are given	Bool_t fNewData; // flag to control when new data are given
	Bool_t fUseMinMaxFromData; // flag top control if min and max must be us ed from data	Bool_t fUseMinMaxFromData; // flag top control if min and max must be us ed from data

	skipping to change at line 167	skipping to change at line 178
	std::vector<Double_t> fKernelSigmas2;	std::vector<Double_t> fKernelSigmas2;

	std::vector<UInt_t> fBinCount; // Number of events per bin for binned da ta option	std::vector<UInt_t> fBinCount; // Number of events per bin for binned da ta option

	std::vector<Bool_t> fSettedOptions; // User input options flag	std::vector<Bool_t> fSettedOptions; // User input options flag

	struct KernelIntegrand;	struct KernelIntegrand;
	friend struct KernelIntegrand;	friend struct KernelIntegrand;

	void Instantiate(KernelFunction_Ptr kernfunc, UInt_t events, const Doubl e_t* data,	void Instantiate(KernelFunction_Ptr kernfunc, UInt_t events, const Doubl e_t* data,

	Double_t xMin, Double_t xMax, Option_t* option, Double_ t rho);	Double_t xMin, Double_t xMax, const Option_t* option, D ouble_t rho);

	inline Double_t GaussianKernel(Double_t x) const {	inline Double_t GaussianKernel(Double_t x) const {
	// Returns the kernel evaluation at x	// Returns the kernel evaluation at x

	return (x > -9. && x < 9.) ? _2_PI_ROOT_INV * std::exp(-.5 * x * x) :	Double_t k2_PI_ROOT_INV = 0.398942280401432703; // (2 * M_PI)**-0.5
	0.0;	return (x > -9. && x < 9.) ? k2_PI_ROOT_INV * std::exp(-.5 * x * x) :
		0.0;
	}	}
	inline Double_t EpanechnikovKernel(Double_t x) const {	inline Double_t EpanechnikovKernel(Double_t x) const {
	return (x > -1. && x < 1.) ? 3. / 4. * (1. - x * x) : 0.0;	return (x > -1. && x < 1.) ? 3. / 4. * (1. - x * x) : 0.0;
	}	}
	inline Double_t BiweightKernel(Double_t x) const {	inline Double_t BiweightKernel(Double_t x) const {
	// Returns the kernel evaluation at x	// Returns the kernel evaluation at x
	return (x > -1. && x < 1.) ? 15. / 16. * (1. - x * x) * (1. - x * x) : 0.0;	return (x > -1. && x < 1.) ? 15. / 16. * (1. - x * x) * (1. - x * x) : 0.0;
	}	}
	inline Double_t CosineArchKernel(Double_t x) const {	inline Double_t CosineArchKernel(Double_t x) const {
	// Returns the kernel evaluation at x	// Returns the kernel evaluation at x

	return (x > -1. && x < 1.) ? PI_OVER4 * std::cos(PI_OVER2 * x) : 0.0 ;	return (x > -1. && x < 1.) ? M_PI_4 * std::cos(M_PI_2 * x) : 0.0;
	}	}
	Double_t UpperConfidenceInterval(const Double_t* x, const Double_t* p) c onst; // Valid if the bandwidth is small compared to nEvents**1/5	Double_t UpperConfidenceInterval(const Double_t* x, const Double_t* p) c onst; // Valid if the bandwidth is small compared to nEvents**1/5
	Double_t LowerConfidenceInterval(const Double_t* x, const Double_t* p) c onst; // Valid if the bandwidth is small compared to nEvents**1/5	Double_t LowerConfidenceInterval(const Double_t* x, const Double_t* p) c onst; // Valid if the bandwidth is small compared to nEvents**1/5
	Double_t ApproximateBias(const Double_t* x, const Double_t* ) const { re turn GetBias(*x); }	Double_t ApproximateBias(const Double_t* x, const Double_t* ) const { re turn GetBias(*x); }
	Double_t ComputeKernelL2Norm() const;	Double_t ComputeKernelL2Norm() const;
	Double_t ComputeKernelSigma2() const;	Double_t ComputeKernelSigma2() const;
	Double_t ComputeKernelMu() const;	Double_t ComputeKernelMu() const;
	Double_t ComputeKernelIntegral() const;	Double_t ComputeKernelIntegral() const;
	Double_t ComputeMidspread() ;	Double_t ComputeMidspread() ;


	skipping to change at line 209	skipping to change at line 221
	void SetKernelSigma2();	void SetKernelSigma2();
	void SetCanonicalBandwidths();	void SetCanonicalBandwidths();
	void SetKernelSigmas2();	void SetKernelSigmas2();
	void SetHistogram();	void SetHistogram();
	void SetUseBins();	void SetUseBins();
	void SetMirror();	void SetMirror();
	void SetMean();	void SetMean();
	void SetSigma(Double_t R);	void SetSigma(Double_t R);
	void SetKernel();	void SetKernel();
	void SetKernelFunction(KernelFunction_Ptr kernfunc = 0);	void SetKernelFunction(KernelFunction_Ptr kernfunc = 0);

	void SetOptions(Option_t* option, Double_t rho);	void SetOptions(const Option_t* option, Double_t rho);
	void CheckOptions(Bool_t isUserDefinedKernel = kFALSE);	void CheckOptions(Bool_t isUserDefinedKernel = kFALSE);
	void GetOptions(std::string optionType, std::string option);	void GetOptions(std::string optionType, std::string option);
	void AssureOptions();	void AssureOptions();
	void SetData(const Double_t* data);	void SetData(const Double_t* data);
	void InitFromNewData();	void InitFromNewData();
	void SetMirroredEvents();	void SetMirroredEvents();

		void SetDrawOptions(const Option_t* option, TString& plotOpt, TString& d
	TH1D* GetKDEHistogram(UInt_t nbins, Double_t xMin, Double_t xMax, Bool_t	rawOpt);
	reNorm = kFALSE);	void DrawErrors(TString& drawOpt);
		void DrawConfidenceInterval(TString& drawOpt, double cl=0.95);

	TF1* GetKDEFunction(UInt_t npx = 100, Double_t xMin = 1.0, Double_t xMax = 0.0);	TF1* GetKDEFunction(UInt_t npx = 100, Double_t xMin = 1.0, Double_t xMax = 0.0);
	TF1* GetKDEApproximateBias(UInt_t npx = 100, Double_t xMin = 1.0, Double _t xMax = 0.0);	TF1* GetKDEApproximateBias(UInt_t npx = 100, Double_t xMin = 1.0, Double _t xMax = 0.0);
	// The density to estimate should be at least twice differentiable.	// The density to estimate should be at least twice differentiable.

	TF1* GetPDFUpperConfidenceInterval(Double_t confidenceLevel, UInt_t npx	TF1* GetPDFUpperConfidenceInterval(Double_t confidenceLevel = 0.95, UInt
	= 100, Double_t xMin = 1.0, Double_t xMax = 0.0);	_t npx = 100, Double_t xMin = 1.0, Double_t xMax = 0.0);
	TF1* GetPDFLowerConfidenceInterval(Double_t confidenceLevel, UInt_t npx	TF1* GetPDFLowerConfidenceInterval(Double_t confidenceLevel = 0.95, UInt
	= 100, Double_t xMin = 1.0, Double_t xMax = 0.0);	_t npx = 100, Double_t xMin = 1.0, Double_t xMax = 0.0);

	ClassDef(TKDE, 1) // One dimensional semi-parametric Kernel Density Esti mation	ClassDef(TKDE, 1) // One dimensional semi-parametric Kernel Density Esti mation

	};	};

	#endif	#endif

End of changes. 22 change blocks.
	41 lines changed or deleted	55 lines changed or added

	TLockFile.h	TLockFile.h

	// @(#)root/thread:$Id: TLockFile.h 28363 2009-04-27 15:12:11Z rdm $	// @(#)root/io:$Id: TLockFile.h 36484 2010-11-02 16:00:10Z rdm $
	// Author: Jan Fiete Grosse-Oetringhaus, 04.06.07	// Author: Jan Fiete Grosse-Oetringhaus, 04.06.07

	/*************************************************************************	/*************************************************************************
	* 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. *
	*************************************************************************/	*************************************************************************/


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

	TMakeProject.h	TMakeProject.h

	// @(#)root/io:$Id: TMakeProject.h 32336 2010-02-12 15:03:23Z pcanal $	// @(#)root/io:$Id: TMakeProject.h 36707 2010-11-16 20:00:58Z pcanal $
	// Author: Rene Brun 12/10/2000	// Author: Rene Brun 12/10/2000

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, 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 29	skipping to change at line 29
	// Helper class implementing the TFile::MakeProject. //	// Helper class implementing the TFile::MakeProject. //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#include <stdio.h>	#include <stdio.h>
	#ifndef ROOT_TOBJECT_H	#ifndef ROOT_TOBJECT_H
	#include "TString.h"	#include "TString.h"
	#endif	#endif

	class TList;	class TList;

		class TVirtualStreamerInfo;
	class TStreamerElement;	class TStreamerElement;

	class TMakeProject	class TMakeProject
	{	{
	private:	private:
	static void GenerateMissingStreamerInfo(TList extrainfos, const char c lname, Bool_t iscope);	static void GenerateMissingStreamerInfo(TList extrainfos, const char c lname, Bool_t iscope);
	public:	public:
	static void AddUniqueStatement(FILE fp, const char statement, char *in clist);	static void AddUniqueStatement(FILE fp, const char statement, char *in clist);
	static void AddInclude(FILE fp, const char header, Bool_t system, char *inclist);	static void AddInclude(FILE fp, const char header, Bool_t system, char *inclist);
	static void ChopFileName(TString &name, Int_t limit);	static void ChopFileName(TString &name, Int_t limit);
	static TString GetHeaderName(const char name, const TList extrainfos, Bool_t includeNested = kFALSE);	static TString GetHeaderName(const char name, const TList extrainfos, Bool_t includeNested = kFALSE);
	static UInt_t GenerateClassPrefix(FILE fp, const char clname, Bool_t t op, TString &protoname, UInt_t *numberOfClasses, Int_t implementEmptyClass = kFALSE, Bool_t needGenericTemplate = kFALSE);	static UInt_t GenerateClassPrefix(FILE fp, const char clname, Bool_t t op, TString &protoname, UInt_t *numberOfClasses, Int_t implementEmptyClass = kFALSE, Bool_t needGenericTemplate = kFALSE);
	static void GenerateMissingStreamerInfos(TList extrainfos, TStreamerEle ment element);	static void GenerateMissingStreamerInfos(TList extrainfos, TStreamerEle ment element);
	static void GenerateMissingStreamerInfos(TList extrainfos, const char clname);	static void GenerateMissingStreamerInfos(TList extrainfos, const char clname);
	static UInt_t GenerateForwardDeclaration(FILE fp, const char clname, c har inclist, Bool_t implementEmptyClass, Bool_t needGenericTemplate, const TList extrainfos);	static UInt_t GenerateForwardDeclaration(FILE fp, const char clname, c har inclist, Bool_t implementEmptyClass, Bool_t needGenericTemplate, const TList extrainfos);
	static UInt_t GenerateIncludeForTemplate(FILE fp, const char clname, c har inclist, Bool_t forward, const TList extrainfos);	static UInt_t GenerateIncludeForTemplate(FILE fp, const char clname, c har inclist, Bool_t forward, const TList extrainfos);
	static TString UpdateAssociativeToVector(const char *name);	static TString UpdateAssociativeToVector(const char *name);

		static void GeneratePostDeclaration(FILE fp, const TVirtualStreamerInfo info, char *inclist);
	};	};

	#endif // ROOT_TMakeProject	#endif // ROOT_TMakeProject

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

	TMath.h	TMath.h

	// @(#)root/mathcore:$Id: TMath.h 34992 2010-08-25 10:36:11Z moneta $	// @(#)root/mathcore:$Id: TMath.h 36792 2010-11-19 16:53:42Z rdm $
	// Authors: Rene Brun, Anna Kreshuk, Eddy Offermann, Fons Rademakers 29/0 7/95	// Authors: Rene Brun, Anna Kreshuk, Eddy Offermann, Fons Rademakers 29/0 7/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 344	skipping to change at line 344
	#include <float.h>	#include <float.h>

	#if defined(R__WIN32) && !defined(__CINT__)	#if defined(R__WIN32) && !defined(__CINT__)
	# ifndef finite	# ifndef finite
	# define finite _finite	# define finite _finite
	# define isnan _isnan	# define isnan _isnan
	# endif	# endif
	#endif	#endif
	#if defined(R__AIX) \|\| defined(R__SOLARIS_CC50) \|\| \	#if defined(R__AIX) \|\| defined(R__SOLARIS_CC50) \|\| \
	defined(R__HPUX11) \|\| defined(R__GLIBC) \|\| \	defined(R__HPUX11) \|\| defined(R__GLIBC) \|\| \

	(defined(R__MACOSX) && defined(__INTEL_COMPILER))	(defined(R__MACOSX) && (defined(__INTEL_COMPILER) \|\| defined(__arm__)))
	// math functions are defined inline so we have to include them here	// math functions are defined inline so we have to include them here
	# include <math.h>	# include <math.h>
	# ifdef R__SOLARIS_CC50	# ifdef R__SOLARIS_CC50
	extern "C" { int finite(double); }	extern "C" { int finite(double); }
	# endif	# endif
	# if defined(R__GLIBC) && defined(__STRICT_ANSI__)	# if defined(R__GLIBC) && defined(__STRICT_ANSI__)
	# ifndef finite	# ifndef finite
	# define finite __finite	# define finite __finite
	# endif	# endif
	# ifndef isnan	# ifndef isnan

	skipping to change at line 465	skipping to change at line 465
	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::Log(Double_t x)	inline Double_t TMath::Log(Double_t x)
	{ return log(x); }	{ return log(x); }

	inline Double_t TMath::Log10(Double_t x)	inline Double_t TMath::Log10(Double_t x)
	{ return log10(x); }	{ return log10(x); }

	inline Int_t TMath::Finite(Double_t x)	inline Int_t TMath::Finite(Double_t x)

	#ifdef R__HPUX11	#if defined(R__HPUX11)
	{ return isfinite(x); }	{ return isfinite(x); }

		#elif defined(R__MACOSX) && defined(__arm__)
		#ifdef isfinite
		// from math.h
		{ return isfinite(x); }
		#else
		// from cmath
		{ return std::isfinite(x); }
		#endif
	#else	#else
	{ return finite(x); }	{ return finite(x); }
	#endif	#endif

	inline Int_t TMath::IsNaN(Double_t x)	inline Int_t TMath::IsNaN(Double_t x)

		#if defined(R__MACOSX) && defined(__arm__)
		#ifdef isnan
		// from math.h
		{ return isnan(x); }
		#else
		// from cmath
		{ return std::isnan(x); }
		#endif
		#else
	{ return isnan(x); }	{ return isnan(x); }

		#endif

	//-------- Advanced -------------	//-------- Advanced -------------

	template <typename T> inline T TMath::NormCross(const T v1[3],const T v2[3] ,T out[3])	template <typename T> inline T TMath::NormCross(const T v1[3],const T v2[3] ,T out[3])
	{	{
	// Calculate the Normalized Cross Product of two vectors	// Calculate the Normalized Cross Product of two vectors
	return Normalize(Cross(v1,v2,out));	return Normalize(Cross(v1,v2,out));
	}	}

	template <typename T>	template <typename T>

	skipping to change at line 830	skipping to change at line 848
	v2[1] = p3[1] - p1[1];	v2[1] = p3[1] - p1[1];
	v2[2] = p3[2] - p1[2];	v2[2] = p3[2] - p1[2];

	NormCross(v1,v2,normal);	NormCross(v1,v2,normal);
	return normal;	return normal;
	}	}

	template <typename T> Bool_t TMath::IsInside(T xp, T yp, Int_t np, T x, T y)	template <typename T> Bool_t TMath::IsInside(T xp, T yp, Int_t np, T x, T y)
	{	{
	// Function which returns kTRUE if point xp,yp lies inside the	// Function which returns kTRUE if point xp,yp lies inside the

	// polygon defined by the np points in arrays x and y, kFALSE otherwise	// polygon defined by the np points in arrays x and y, kFALSE otherwise.
	// NOTE that the polygon must be a closed polygon (1st and last point	// Note that the polygon may be open or closed.
	// must be identical).
		Int_t i, j = np-1 ;
	Double_t xint;	Bool_t oddNodes = kFALSE;
	Int_t i;
	Int_t inter = 0;	for (i=0; i<np; i++) {
	for (i=0;i<np-1;i++) {	if ((y[i]<yp && y[j]>=yp) \|\| (y[j]<yp && y[i]>=yp)) {
	if (y[i] == y[i+1]) continue;	if (x[i]+(yp-y[i])/(y[j]-y[i])*(x[j]-x[i])<xp) {
	if (yp <= y[i] && yp <= y[i+1]) continue;	oddNodes = !oddNodes;
	if (y[i] < yp && y[i+1] < yp) continue;	}
	xint = x[i] + (yp-y[i])*(x[i+1]-x[i])/(y[i+1]-y[i]);	}
	if ((Double_t)xp < xint) inter++;	j=i;
	}	}

	if (inter%2) return kTRUE;
	return kFALSE;	return oddNodes;
	}	}

	template <typename T> Double_t TMath::Median(Long64_t n, const T a, const Double_t w, Long64_t *work)	template <typename T> Double_t TMath::Median(Long64_t n, const T a, const Double_t w, Long64_t *work)
	{	{
	// Return the median of the array a where each entry i has weight w[i] .	// Return the median of the array a where each entry i has weight w[i] .
	// Both arrays have a length of at least n . The median is a number obta ined	// Both arrays have a length of at least n . The median is a number obta ined
	// from the sorted array a through	// from the sorted array a through
	//	//
	// median = (a[jl]+a[jh])/2. where (using also the sorted index on the array w)	// median = (a[jl]+a[jh])/2. where (using also the sorted index on the array w)
	//	//

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

	TMemStat.h	TMemStat.h

	// @(#)root/memstat:$Id: TMemStat.h 35660 2010-09-23 14:02:09Z brun $	// @(#)root/memstat:$Id: TMemStat.h 36382 2010-10-20 12:27:40Z brun $
	// Author: Anar Manafov (A.Manafov@gsi.de) 2008-03-02	// Author: Anar Manafov (A.Manafov@gsi.de) 2008-03-02

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2010, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2010, 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_TMemStat	#ifndef ROOT_TMemStat
	#define ROOT_TMemStat	#define ROOT_TMemStat

	class TMemStat: public TObject {	class TMemStat: public TObject {
	private:	private:
	Bool_t fIsActive; // is object attached to MemStat	Bool_t fIsActive; // is object attached to MemStat

	public:	public:

	TMemStat(Option_t* option = "read", Long64_t maxcalls=5000000);	TMemStat(Option_t* option = "read", Int_t buffersize=10000, Int_t maxcal ls=5000000);
	virtual ~TMemStat();	virtual ~TMemStat();
	static void Close();	static void Close();
	virtual void Disable();	virtual void Disable();
	virtual void Enable();	virtual void Enable();

	static void Show(Double_t update=0.01, const char* fname="*");	static void Show(Double_t update=0.1, Int_t nbigleaks=20, const char* f name="*");

	ClassDef(TMemStat, 0) // a user interface class of MemStat	ClassDef(TMemStat, 0) // a user interface class of MemStat
	};	};

	#endif	#endif

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

	TMemStatMng.h	TMemStatMng.h

	// @(#)root/memstat:$Id: TMemStatMng.h 35660 2010-09-23 14:02:09Z brun $	// @(#)root/memstat:$Id: TMemStatMng.h 36382 2010-10-20 12:27:40Z brun $
	// Author: Anar Manafov (A.Manafov@gsi.de) 2008-03-02	// Author: Anar Manafov (A.Manafov@gsi.de) 2008-03-02

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2010, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2010, 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_TMemStatMng	#ifndef ROOT_TMemStatMng

	skipping to change at line 84	skipping to change at line 84

	private:	private:
	TMemStatMng();	TMemStatMng();
	virtual ~TMemStatMng();	virtual ~TMemStatMng();

	public:	public:
	void Enable(); //enable memory statistic	void Enable(); //enable memory statistic
	void Disable(); //Disable memory statistic	void Disable(); //Disable memory statistic
	static TMemStatMng* GetInstance(); //get instance of class - ONLY O NE INSTANCE	static TMemStatMng* GetInstance(); //get instance of class - ONLY O NE INSTANCE
	static void Close(); //close MemStatManager	static void Close(); //close MemStatManager

	void SetMaxcalls(Long64_t maxcalls);	void SetBufferSize(Int_t buffersize);
		void SetMaxCalls(Int_t maxcalls);

	public:	public:
	//stack data members	//stack data members
	void SetUseGNUBuiltinBacktrace(Bool_t newVal) {	void SetUseGNUBuiltinBacktrace(Bool_t newVal) {
	fUseGNUBuiltinBacktrace = newVal;	fUseGNUBuiltinBacktrace = newVal;
	}	}

	protected:	protected:
	#if !defined(__APPLE__)	#if !defined(__APPLE__)
	TMemStatHook::MallocHookFunc_t fPreviousMallocHook; //!old malloc function	TMemStatHook::MallocHookFunc_t fPreviousMallocHook; //!old malloc function
	TMemStatHook::FreeHookFunc_t fPreviousFreeHook; //!old free fu nction	TMemStatHook::FreeHookFunc_t fPreviousFreeHook; //!old free fu nction
	#endif	#endif
	void Init();	void Init();
	void AddPointer(void *ptr, Int_t size); //add pointer to the table	void AddPointer(void *ptr, Int_t size); //add pointer to the table

		void FillTree();
	static void AllocHook(size_t size, const void /caller/);	static void AllocHook(size_t size, const void /caller/);
	static void FreeHook(void* ptr, const void* /caller/);	static void FreeHook(void* ptr, const void* /caller/);
	static void MacAllocHook(void *ptr, size_t size);	static void MacAllocHook(void *ptr, size_t size);
	static void MacFreeHook(void *ptr);	static void MacFreeHook(void *ptr);
	Int_t generateBTID(UChar_t *CRCdigest, Int_t stackEntries,	Int_t generateBTID(UChar_t *CRCdigest, Int_t stackEntries,
	void **stackPointers);	void **stackPointers);

	// memory information	// memory information
	TFile* fDumpFile; //!file to dump current information	TFile* fDumpFile; //!file to dump current information
	TTree *fDumpTree; //!tree to dump information	TTree *fDumpTree; //!tree to dump information
	static TMemStatMng *fgInstance; // pointer to instance	static TMemStatMng *fgInstance; // pointer to instance
	static void *fgStackTop; // stack top pointer	static void *fgStackTop; // stack top pointer

	Bool_t fUseGNUBuiltinBacktrace;	Bool_t fUseGNUBuiltinBacktrace;
	TTimeStamp fTimeStamp;	TTimeStamp fTimeStamp;

	Double_t fBeginTime; //time when monitoring starts	Double_t fBeginTime; //time when monitoring starts
	ULong64_t fPos; //position in memory where alloc/free happens	ULong64_t fPos; //position in memory where alloc/free happens
	Int_t fTimems; //10000*(current time - begin time)	Int_t fTimems; //10000*(current time - begin time)
	Int_t fNBytes; //number of bytes allocated/freed	Int_t fNBytes; //number of bytes allocated/freed
	UInt_t fN;	Int_t fBtID; //back trace identifier
	Int_t fBtID; //back trace identifier	Int_t fMaxCalls; //max number of malloc/frees to register in t
	Long64_t fMaxCalls; //max number of malloc/frees to register in t	he output Tree
	he output Tree	Int_t fBufferSize; //max number of malloc/free to keep in the bu
		ffer
		Int_t fBufN; //current number of alloc or free in the buff
		er
		ULong64_t *fBufPos; //position in memory where alloc/free happens
		Int_t fBufTimems; //10000(current time - begin time)
		Int_t *fBufNBytes; //number of bytes allocated/freed
		Int_t *fBufBtID; //back trace identifier
		Int_t *fIndex; //array to sort fBufPos
		Bool_t *fMustWrite; //flag to write or not the entry

	private:	private:
	TMemStatFAddrContainer fFAddrs;	TMemStatFAddrContainer fFAddrs;
	TObjArray *fFAddrsList;	TObjArray *fFAddrsList;
	TH1I *fHbtids;	TH1I *fHbtids;
	CRCSet_t fBTChecksums;	CRCSet_t fBTChecksums;
	Int_t fBTCount;	Int_t fBTCount;
	// for Debug. A counter of all (de)allacations.	// for Debug. A counter of all (de)allacations.
	UInt_t fBTIDCount;	UInt_t fBTIDCount;
	TNamed *fSysInfo;	TNamed *fSysInfo;

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

	TMemStatShow.h	TMemStatShow.h

	// @(#)root/treeviewer:$Id: TMemStatShow.h 35621 2010-09-23 07:55:59Z brun $	// @(#)root/treeviewer:$Id: TMemStatShow.h 37300 2010-12-05 17:25:20Z brun $
	// Author: Rene Brun 21/09/2010	// Author: Rene Brun 21/09/2010

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2010, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2010, 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 27	skipping to change at line 27
	// TMemStatShow //	// TMemStatShow //
	// //	// //
	// class to visualize the results of TMemStat //	// class to visualize the results of TMemStat //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TObject	#ifndef ROOT_TObject
	#include "TObject.h"	#include "TObject.h"
	#endif	#endif


		class TTree;
		class TH1D;
		class TH1I;
		class TGToolTip;
		class TObjArray;
		class TCanvas;

	class TMemStatShow : public TObject {	class TMemStatShow : public TObject {


		protected:
		static TTree *fgT; //TMemStat Tree
		static TH1D *fgHalloc; //histogram with allocations
		static TH1D *fgHfree; //histogram with frees
		static TH1D *fgH; //histogram with allocations - frees
		static TH1I *fgHleaks; //histogram with leaks
		static TH1I *fgHentry; //histogram with entry numbers in the TObj
		Array
		static TH1I *fgHdiff; //histogram with diff of entry number betw
		een alloc/free

		static TGToolTip *fgTip1; //pointer to tool tip for canvas 1
		static TGToolTip *fgTip2; //pointer to tool tip for canvas 2
		static TObjArray *fgBtidlist; //list of back trace ids
		static Double_t *fgV1; //pointer to V1 array of TTree::Draw (pos)
		static Double_t *fgV2; //pointer to V2 array of TTree::Draw (nbyt
		es)
		static Double_t *fgV3; //pointer to V3 array of TTree::Draw (time
		)
		static Double_t *fgV4; //pointer to V4 array of TTree::Draw (btid
		)
		static TCanvas *fgC1; //pointer to canvas showing allocs/dealloc
		s vs time
		static TCanvas *fgC2; //pointer to canvas with leaks in decreasi
		ng order
		static TCanvas *fgC3; //pointer to canvas showing the main leaks

		static Long64_t fgAddressFirst; //first address to process
		static Long64_t fgAddressN; //number of addresses in bytes to proces
		s
		static Long64_t fgEntryFirst; //first entry to process
		static Long64_t fgEntryN; //number of entries to process

	public:	public:
	TMemStatShow() {;}	TMemStatShow() {;}
	virtual ~TMemStatShow() {;}	virtual ~TMemStatShow() {;}

	static void EventInfo(Int_t event, Int_t px, Int_t py, TObject *selected	static void EventInfo1(Int_t event, Int_t px, Int_t py, TObject *selecte
	);	d);
		static void EventInfo2(Int_t event, Int_t px, Int_t py, TObject *selecte
	static void Show(Double_t update=0.01, const char* fname="*");	d);
		static void FillBTString(Int_t bin, Int_t mode, TString &btstring);

		static void SetAddressRange(Long64_t nbytes=0, Long64_t first=0);
		static void SetEntryRange(Long64_t nentries=0, Long64_t first=0);
		static void Show(Double_t update=0.1, Int_t nbigleaks=20, const char* fn
		ame="*");

	ClassDef(TMemStatShow,0) //class to visualize the results of TMemStat	ClassDef(TMemStatShow,0) //class to visualize the results of TMemStat
	};	};

	#endif	#endif

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

	TPacketizerFile.h	TPacketizerFile.h

	// @(#)root/proofplayer:$Id: TPacketizerFile.h 33642 2010-05-28 14:12:11Z g anis $	// @(#)root/proofplayer:$Id: TPacketizerFile.h 36876 2010-11-23 11:45:47Z g anis $
	// Author: G. Ganis 2009	// Author: G. Ganis 2009

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2002, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2002, 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 46	skipping to change at line 46
	class TPacketizerFile : public TVirtualPacketizer {	class TPacketizerFile : public TVirtualPacketizer {

	public: // This is always needed	public: // This is always needed
	class TSlaveStat;	class TSlaveStat;
	class TIterObj;	class TIterObj;

	private:	private:
	TMap *fFiles; // Files to be produced/processed per node	TMap *fFiles; // Files to be produced/processed per node
	TList *fNotAssigned; // List of files not assigned to a specifi c node	TList *fNotAssigned; // List of files not assigned to a specifi c node
	TList *fIters; // Iterators on the file lists per node	TList *fIters; // Iterators on the file lists per node

	Long64_t fAssigned; // no. files processed or being processed.	Long64_t fAssigned; // No.files processed or being processed.
		Bool_t fProcNotAssigned; // Whether to process files not asdigned t
		o a worker

	TStopwatch *fStopwatch; // For measuring the start time of each pa cket	TStopwatch *fStopwatch; // For measuring the start time of each pa cket

	TPacketizerFile();	TPacketizerFile();
	// : fFiles(0), fIters(0), fAssigned(0), fStopwatch(0) { }	// : fFiles(0), fIters(0), fAssigned(0), fStopwatch(0) { }
	TPacketizerFile(const TPacketizerFile&); // no implementation, will generate	TPacketizerFile(const TPacketizerFile&); // no implementation, will generate
	void operator=(const TPacketizerFile&); // error on accidental usage	void operator=(const TPacketizerFile&); // error on accidental usage

	public:	public:
	TPacketizerFile(TList workers, Long64_t, TList input, TProofProgressSt atus *st = 0);	TPacketizerFile(TList workers, Long64_t, TList input, TProofProgressSt atus *st = 0);

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

	TProofPlayer.h	TProofPlayer.h

	// @(#)root/proofplayer:$Id: TProofPlayer.h 34081 2010-06-23 10:59:01Z gani s $	// @(#)root/proofplayer:$Id: TProofPlayer.h 36592 2010-11-11 10:43:17Z gani s $
	// Author: Maarten Ballintijn 07/01/02	// Author: Maarten Ballintijn 07/01/02

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2001, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2001, 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 124	skipping to change at line 124

	protected:	protected:
	class TCleanup {	class TCleanup {
	private:	private:
	TProofPlayer *fPlayer;	TProofPlayer *fPlayer;
	public:	public:
	TCleanup(TProofPlayer *p) : fPlayer(p) { }	TCleanup(TProofPlayer *p) : fPlayer(p) { }
	~TCleanup() { fPlayer->StopFeedback(); }	~TCleanup() { fPlayer->StopFeedback(); }
	};	};


		Bool_t CheckMemUsage(Long64_t &mfreq, Bool_t &w80r, Bool_t &w80v, TStrin
		g &wmsg);

	void MapOutputListToDataMembers() const;	void MapOutputListToDataMembers() const;

	public:	public:
	enum EStatusBits { kDispatchOneEvent = BIT(15), kIsProcessing = BIT(16) };	enum EStatusBits { kDispatchOneEvent = BIT(15), kIsProcessing = BIT(16) };

	TProofPlayer(TProof *proof = 0);	TProofPlayer(TProof *proof = 0);
	virtual ~TProofPlayer();	virtual ~TProofPlayer();

	Long64_t Process(TDSet *set,	Long64_t Process(TDSet *set,
	const char selector, Option_t option = "",	const char selector, Option_t option = "",

	skipping to change at line 268	skipping to change at line 270
	TDSet *fDSet; //!tdset for current processing	TDSet *fDSet; //!tdset for current processing
	ErrorHandlerFunc_t fErrorHandler; // Store previous handler when redir ecting output	ErrorHandlerFunc_t fErrorHandler; // Store previous handler when redir ecting output

	virtual Bool_t HandleTimer(TTimer *timer);	virtual Bool_t HandleTimer(TTimer *timer);
	Int_t InitPacketizer(TDSet *dset, Long64_t nentries,	Int_t InitPacketizer(TDSet *dset, Long64_t nentries,
	Long64_t first, const char *defpackunit,	Long64_t first, const char *defpackunit,
	const char *defpackdata);	const char *defpackdata);
	TList *MergeFeedback();	TList *MergeFeedback();
	Bool_t MergeOutputFiles();	Bool_t MergeOutputFiles();
	void NotifyMemory(TObject *obj);	void NotifyMemory(TObject *obj);

		void SetLastMergingMsg(TObject *obj);
	virtual Bool_t SendSelector(const char *selector_file); //send selector to slaves	virtual Bool_t SendSelector(const char *selector_file); //send selector to slaves
	TProof *GetProof() const { return fProof; }	TProof *GetProof() const { return fProof; }
	void SetupFeedback(); // specialized setup	void SetupFeedback(); // specialized setup
	void StopFeedback(); // specialized teardown	void StopFeedback(); // specialized teardown
	void SetSelectorDataMembersFromOutputList();	void SetSelectorDataMembersFromOutputList();

	public:	public:
	TProofPlayerRemote(TProof *proof = 0) : fProof(proof), fOutputLists(0), fFeedback(0),	TProofPlayerRemote(TProof *proof = 0) : fProof(proof), fOutputLists(0), fFeedback(0),
	fFeedbackLists(0), fPacketizer(0 ),	fFeedbackLists(0), fPacketizer(0 ),
	fMergeFiles(kFALSE), fDSet(0), f ErrorHandler(0)	fMergeFiles(kFALSE), fDSet(0), f ErrorHandler(0)

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

	TProofProgressDialog.h	TProofProgressDialog.h

	// @(#)root/sessionviewer:$Id: TProofProgressDialog.h 30862 2009-10-25 08:2 6:46Z ganis $	// @(#)root/sessionviewer:$Id: TProofProgressDialog.h 36073 2010-10-05 08:1 4:21Z ganis $
	// Author: Fons Rademakers 21/03/03	// Author: Fons Rademakers 21/03/03

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2003, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2003, 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 61	skipping to change at line 61

	TGTransientFrame *fDialog; // transient frame, main dialog window	TGTransientFrame *fDialog; // transient frame, main dialog window
	TGProgressBar *fBar; // progress bar	TGProgressBar *fBar; // progress bar
	TGTextButton *fClose;	TGTextButton *fClose;
	TGTextButton *fStop;	TGTextButton *fStop;
	TGTextButton *fAbort;	TGTextButton *fAbort;
	TGTextButton *fAsyn;	TGTextButton *fAsyn;
	TGTextButton *fLog;	TGTextButton *fLog;
	TGTextButton *fRatePlot;	TGTextButton *fRatePlot;
	TGTextButton *fMemPlot;	TGTextButton *fMemPlot;

		TGTextButton *fUpdtSpeedo;
	TGCheckButton *fKeepToggle;	TGCheckButton *fKeepToggle;
	TGCheckButton *fLogQueryToggle;	TGCheckButton *fLogQueryToggle;
	TGTextBuffer *fTextQuery;	TGTextBuffer *fTextQuery;
	TGTextEntry *fEntry;	TGTextEntry *fEntry;
	TGLabel *fTitleLab;	TGLabel *fTitleLab;
	TGLabel *fFilesEvents;	TGLabel *fFilesEvents;
	TGLabel *fTimeLab;	TGLabel *fTimeLab;
	TGLabel *fProcessed;	TGLabel *fProcessed;
	TGLabel *fEstim;	TGLabel *fEstim;
	TGLabel *fTotal;	TGLabel *fTotal;
	TGLabel *fRate;	TGLabel *fRate;
	TGLabel *fInit;	TGLabel *fInit;
	TGLabel *fSelector;	TGLabel *fSelector;

		Bool_t fSpeedoEnabled; // whether to enable the speedome ter
	TGSpeedo *fSpeedo; // speedometer	TGSpeedo *fSpeedo; // speedometer
	TGCheckButton *fSmoothSpeedo; // use smooth speedometer update	TGCheckButton *fSmoothSpeedo; // use smooth speedometer update
	TProofProgressLog *fLogWindow; // transient frame for logs	TProofProgressLog *fLogWindow; // transient frame for logs
	TProofProgressMemoryPlot *fMemWindow; // transient frame for memory plo ts	TProofProgressMemoryPlot *fMemWindow; // transient frame for memory plo ts
	TProof *fProof;	TProof *fProof;
	TTime fStartTime;	TTime fStartTime;
	TTime fEndTime;	TTime fEndTime;
	Long64_t fPrevProcessed;	Long64_t fPrevProcessed;
	Long64_t fPrevTotal;	Long64_t fPrevTotal;
	Long64_t fFirst;	Long64_t fFirst;

	skipping to change at line 139	skipping to change at line 141
	void CloseWindow();	void CloseWindow();
	void DoClose();	void DoClose();
	void DoLog();	void DoLog();
	void DoKeep(Bool_t on);	void DoKeep(Bool_t on);
	void DoSetLogQuery(Bool_t on);	void DoSetLogQuery(Bool_t on);
	void DoStop();	void DoStop();
	void DoAbort();	void DoAbort();
	void DoAsyn();	void DoAsyn();
	void DoPlotRateGraph();	void DoPlotRateGraph();
	void DoMemoryPlot();	void DoMemoryPlot();

		void DoEnableSpeedo();
	void ToggleOdometerInfos();	void ToggleOdometerInfos();
	void ToggleThreshold();	void ToggleThreshold();

	ClassDef(TProofProgressDialog,0) //PROOF progress dialog	ClassDef(TProofProgressDialog,0) //PROOF progress dialog
	};	};

	#endif	#endif

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

	TProofServ.h	TProofServ.h

	// @(#)root/proof:$Id: TProofServ.h 34101 2010-06-24 12:12:59Z ganis $	// @(#)root/proof:$Id: TProofServ.h 36592 2010-11-11 10:43:17Z ganis $
	// Author: Fons Rademakers 16/02/97	// Author: Fons Rademakers 16/02/97

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, 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 77	skipping to change at line 77
	// For backward compatibility	// For backward compatibility
	typedef Int_t (OldProofServAuthSetup_t)(TSocket , Bool_t, Int_t,	typedef Int_t (OldProofServAuthSetup_t)(TSocket , Bool_t, Int_t,
	TString &, TString &, TString &);	TString &, TString &, TString &);

	class TProofServ : public TApplication {	class TProofServ : public TApplication {

	friend class TProofServLite;	friend class TProofServLite;
	friend class TXProofServ;	friend class TXProofServ;

	public:	public:

		enum EStatusBits { kHighMemory = BIT(16) };
	enum EQueryAction { kQueryOK, kQueryModify, kQueryStop, kQueryEnqueued } ;	enum EQueryAction { kQueryOK, kQueryModify, kQueryStop, kQueryEnqueued } ;

	private:	private:
	TString fService; //service we are running, either "proof serv" or "proofslave"	TString fService; //service we are running, either "proof serv" or "proofslave"
	TString fUser; //user as which we run	TString fUser; //user as which we run
	TString fGroup; //group the user belongs to	TString fGroup; //group the user belongs to
	TString fConfDir; //directory containing cluster config i nformation	TString fConfDir; //directory containing cluster config i nformation
	TString fConfFile; //file containing config information	TString fConfFile; //file containing config information
	TString fWorkDir; //directory containing all proof relate d info	TString fWorkDir; //directory containing all proof relate d info
	TString fImage; //image name of the session	TString fImage; //image name of the session

	skipping to change at line 162	skipping to change at line 163

	TServerSocket *fMergingSocket; // Socket used for merging outputs if su bmerger	TServerSocket *fMergingSocket; // Socket used for merging outputs if su bmerger
	TMonitor *fMergingMonitor; // Monitor for merging sockets	TMonitor *fMergingMonitor; // Monitor for merging sockets
	Int_t fMergedWorkers; // Number of workers merged	Int_t fMergedWorkers; // Number of workers merged

	// Quotas (-1 to disable)	// Quotas (-1 to disable)
	Int_t fMaxQueries; //Max number of queries fully kept	Int_t fMaxQueries; //Max number of queries fully kept
	Long64_t fMaxBoxSize; //Max size of the sandbox	Long64_t fMaxBoxSize; //Max size of the sandbox
	Long64_t fHWMBoxSize; //High-Water-Mark on the sandbox size	Long64_t fHWMBoxSize; //High-Water-Mark on the sandbox size


	// Memory limits (-1 to disable) set by envs ROOTPROOFASSOFT and RPPTPRO	// Memory limits (-1 to disable) set by envs ROOTPROFOASHARD, PROOF_VIRT
	FOASHARD	MEMMAX, PROOF_RESMEMMAX
	Long_t fVirtMemHWM; //Above this we terminate gently (in kB	static Long_t fgVirtMemMax; //Hard limit enforced by the system (i
	)	n kB)
	Long_t fVirtMemMax; //Hard limit enforced by the system (in	static Long_t fgResMemMax; //Hard limit on the resident memory ch
	kB)	ecked
		//in TProofPlayer::Process (in kB)
		static Float_t fgMemHWM; // Threshold fraction of max for warni
		ng and finer monitoring
		static Float_t fgMemStop; // Fraction of max for stop processing

	// In bytes; default is 1MB	// In bytes; default is 1MB
	Long64_t fMsgSizeHWM; //High-Water-Mark on the size of messag es with results	Long64_t fMsgSizeHWM; //High-Water-Mark on the size of messag es with results

	static FILE *fgErrorHandlerFile; // File where to log	static FILE *fgErrorHandlerFile; // File where to log
	static Int_t fgRecursive; // Keep track of recursive inputs durin g processing	static Int_t fgRecursive; // Keep track of recursive inputs durin g processing

	// Control sending information to syslog	// Control sending information to syslog
	static Int_t fgLogToSysLog; // >0 sent to syslog too	static Int_t fgLogToSysLog; // >0 sent to syslog too
	static TString fgSysLogService; // name of the syslog service (eg: pro ofm-0, proofw-0.67)	static TString fgSysLogService; // name of the syslog service (eg: pro ofm-0, proofw-0.67)

	skipping to change at line 229	skipping to change at line 233
	virtual Int_t Setup();	virtual Int_t Setup();
	Int_t SetupCommon();	Int_t SetupCommon();
	virtual void MakePlayer();	virtual void MakePlayer();
	virtual void DeletePlayer();	virtual void DeletePlayer();

	virtual Int_t Fork();	virtual Int_t Fork();
	Int_t GetSessionStatus();	Int_t GetSessionStatus();
	Bool_t IsIdle();	Bool_t IsIdle();
	Bool_t UnlinkDataDir(const char *path);	Bool_t UnlinkDataDir(const char *path);


		static TString fgLastMsg; // Message about status before exception

	public:	public:
	TProofServ(Int_t argc, char argv, FILE flog = 0);	TProofServ(Int_t argc, char argv, FILE flog = 0);
	virtual ~TProofServ();	virtual ~TProofServ();

	virtual Int_t CreateServer();	virtual Int_t CreateServer();

	TProof *GetProof() const { return fProof; }	TProof *GetProof() const { return fProof; }
	const char *GetService() const { return fService; }	const char *GetService() const { return fService; }
	const char *GetConfDir() const { return fConfDir; }	const char *GetConfDir() const { return fConfDir; }
	const char *GetConfFile() const { return fConfFile; }	const char *GetConfFile() const { return fConfFile; }

	skipping to change at line 266	skipping to change at line 272

	Int_t GetTotSessions() const { return fTotSessions; }	Int_t GetTotSessions() const { return fTotSessions; }
	Int_t GetActSessions() const { return fActSessions; }	Int_t GetActSessions() const { return fActSessions; }
	Float_t GetEffSessions() const { return fEffSessions; }	Float_t GetEffSessions() const { return fEffSessions; }

	void GetOptions(Int_t argc, char *argv);	void GetOptions(Int_t argc, char *argv);
	TList *GetEnabledPackages() const { return fEnabledPackages; }	TList *GetEnabledPackages() const { return fEnabledPackages; }

	Int_t GetInflateFactor() const { return fInflateFactor; }	Int_t GetInflateFactor() const { return fInflateFactor; }


	Long_t GetVirtMemHWM() const { return fVirtMemHWM; }	static Long_t GetVirtMemMax();
		static Long_t GetResMemMax();
		static Float_t GetMemHWM();
		static Float_t GetMemStop();

	Long64_t GetMsgSizeHWM() const { return fMsgSizeHWM; }	Long64_t GetMsgSizeHWM() const { return fMsgSizeHWM; }

	const char *GetPrefix() const { return fPrefix; }	const char *GetPrefix() const { return fPrefix; }

	void FlushLogFile();	void FlushLogFile();

	TProofLockPath *GetCacheLock() { return fCacheLock; } //cache dir l ocker; used by TProofPlayer	TProofLockPath *GetCacheLock() { return fCacheLock; } //cache dir l ocker; used by TProofPlayer
	Int_t CopyFromCache(const char *name, Bool_t cpbin);	Int_t CopyFromCache(const char *name, Bool_t cpbin);
	Int_t CopyToCache(const char *name, Int_t opt = 0);	Int_t CopyToCache(const char *name, Int_t opt = 0);

	skipping to change at line 325	skipping to change at line 334

	// Log control	// Log control
	void LogToMaster(Bool_t on = kTRUE) { fSendLogToMaster = on; }	void LogToMaster(Bool_t on = kTRUE) { fSendLogToMaster = on; }

	static FILE SetErrorHandlerFile(FILE ferr);	static FILE SetErrorHandlerFile(FILE ferr);
	static void ErrorHandler(Int_t level, Bool_t abort, const char *locat ion,	static void ErrorHandler(Int_t level, Bool_t abort, const char *locat ion,
	const char *msg);	const char *msg);

	static void ResolveKeywords(TString &fname, const char *path = 0);	static void ResolveKeywords(TString &fname, const char *path = 0);


		static void SetLastMsg(const char *lastmsg);

	static Bool_t IsActive();	static Bool_t IsActive();
	static TProofServ *This();	static TProofServ *This();

	ClassDef(TProofServ,0) //PROOF Server Application Interface	ClassDef(TProofServ,0) //PROOF Server Application Interface
	};	};

	R__EXTERN TProofServ *gProofServ;	R__EXTERN TProofServ *gProofServ;

	class TProofLockPath : public TNamed {	class TProofLockPath : public TNamed {
	private:	private:

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

	TPySelector.h	TPySelector.h

	skipping to change at line 27	skipping to change at line 27
	#ifndef ROOT_TTree	#ifndef ROOT_TTree
	#include "TTree.h"	#include "TTree.h"
	#endif	#endif

	// Python	// Python
	struct _object;	struct _object;
	typedef _object PyObject;	typedef _object PyObject;

	class TPySelector : public TSelector {	class TPySelector : public TSelector {
	public:	public:

		using TSelector::fStatus;
		// using TSelector::fAbort;
		using TSelector::fOption;
		using TSelector::fObject;
		using TSelector::fInput;
		using TSelector::fOutput;

		public:
	TTree* fChain;	TTree* fChain;

	public:	public:
	// ctor/dtor ... cctor and assignment are private in base class	// ctor/dtor ... cctor and assignment are private in base class
	TPySelector( TTree* /* tree / = 0, PyObject self = 0 );	TPySelector( TTree* /* tree / = 0, PyObject self = 0 );
	virtual ~TPySelector();	virtual ~TPySelector();

	// TSelector set of forwarded (overridden) methods	// TSelector set of forwarded (overridden) methods
	virtual Int_t Version() const;	virtual Int_t Version() const;
	virtual Int_t GetEntry( Long64_t entry, Int_t getall = 0 );	virtual Int_t GetEntry( Long64_t entry, Int_t getall = 0 );

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

	TQtApplication.h	TQtApplication.h

	// @(#)root/qt:$Id: TQtApplication.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/qt:$Id: TQtApplication.h 35874 2010-09-30 07:56:02Z brun $
	// Author: Valeri Fine 21/01/2002	// Author: Valeri Fine 21/01/2002

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *
	* Copyright (C) 2002 by Valeri Fine. *	* Copyright (C) 2002 by Valeri Fine. *
	* 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 47	skipping to change at line 47
	static void CreateQApplication(int &argc, char ** argv, bool GUIenabled);	static void CreateQApplication(int &argc, char ** argv, bool GUIenabled);

	void operator=(const TQtApplication&);	void operator=(const TQtApplication&);
	TQtApplication(const TQtApplication&);	TQtApplication(const TQtApplication&);

	protected:	protected:
	static TQtApplication *fgQtApplication;	static TQtApplication *fgQtApplication;

	public:	public:


	TQtApplication() {};	TQtApplication() {fGUIThread=0;};
	TQtApplication(const char appClassName, int &argc, char *argv);	TQtApplication(const char appClassName, int &argc, char *argv);
	virtual ~TQtApplication();	virtual ~TQtApplication();
	static bool Terminate();	static bool Terminate();

	static TQtApplication *GetQtApplication();	static TQtApplication *GetQtApplication();
	static bool IsThisGuiThread();	static bool IsThisGuiThread();
	static Int_t QtVersion();	static Int_t QtVersion();
	ClassDef(TQtApplication,0) // Instantiate the Qt system within ROOT envi ronment	ClassDef(TQtApplication,0) // Instantiate the Qt system within ROOT envi ronment

	};	};

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

	TQtBrush.h	TQtBrush.h

	// @(#)root/qt:$Id: TQtBrush.h 30386 2009-09-23 19:06:28Z brun $	// @(#)root/qt:$Id: TQtBrush.h 36066 2010-10-04 19:41:50Z brun $
	// Author: Valeri Fine 21/01/2002	// Author: Valeri Fine 21/01/2002

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *
	* Copyright (C) 2002 by Valeri Fine. *	* Copyright (C) 2002 by Valeri Fine. *
	* 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 47	skipping to change at line 47
	protected:	protected:
	QColor fBackground;	QColor fBackground;
	int fStyle;	int fStyle;
	int fFasi;	int fFasi;
	int fAlpha; // transparency	int fAlpha; // transparency
	void SetColorOwn();	void SetColorOwn();

	public:	public:
	TQtBrush();	TQtBrush();
	TQtBrush(const TQtBrush &src):QBrush(src)	TQtBrush(const TQtBrush &src):QBrush(src)

	{	,fBackground(src.fBackground)
	fBackground=src.fBackground;	,fStyle(src.fStyle)
	fStyle=src.fStyle;	,fFasi(src.fFasi)
	fFasi=src.fFasi;	,fAlpha(src.fFasi)
	}	{ }
	TQtBrush(const TAttFill &rootFillAttributes);	TQtBrush(const TAttFill &rootFillAttributes);
	virtual ~TQtBrush();	virtual ~TQtBrush();
	TQtBrush &operator=(const TAttFill &rootFillAttributes);	TQtBrush &operator=(const TAttFill &rootFillAttributes);
	void SetFillAttributes(const TAttFill &rootFillAttributes);	void SetFillAttributes(const TAttFill &rootFillAttributes);
	Bool_t IsTransparent() const;	Bool_t IsTransparent() const;
	void SetStyle(int newStyle=1000){ if (newStyle < 0) fStyle = fFasi = -1;	void SetStyle(int newStyle=1000){ if (newStyle < 0) fStyle = fFasi = -1;
	else SetStyle(newStyle/1000,newStyle% 1000);	else SetStyle(newStyle/1000,newStyle% 1000);
	};	};
	void SetStyle(int style, int fasi);	void SetStyle(int style, int fasi);
	void SetColor(const QColor &qtcolor);	void SetColor(const QColor &qtcolor);

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

	TQtMarker.h	TQtMarker.h

	// @(#)root/qt:$Id: TQtMarker.h 33707 2010-06-02 06:27:34Z brun $	// @(#)root/qt:$Id: TQtMarker.h 36066 2010-10-04 19:41:50Z brun $
	// Author: Valeri Fine 21/01/2002	// Author: Valeri Fine 21/01/2002

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *
	* Copyright (C) 2002 by Valeri Fine. *	* Copyright (C) 2002 by Valeri Fine. *
	* 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 83	skipping to change at line 83
	fNumNode = m.fNumNode;	fNumNode = m.fNumNode;
	fChain = m.fChain;	fChain = m.fChain;
	fCindex = m.fCindex;	fCindex = m.fCindex;
	fMarkerType=m.fMarkerType;	fMarkerType=m.fMarkerType;
	fLineWidth =m.fLineWidth;	fLineWidth =m.fLineWidth;
	return *this;	return *this;
	}	}
	//_________________________________________________________	//_________________________________________________________
	inline TQtMarker::TQtMarker(const TQtMarker&m) : fNumNode(m.fNumNode),	inline TQtMarker::TQtMarker(const TQtMarker&m) : fNumNode(m.fNumNode),
	fChain(m.fChain), fCindex(m.fCindex),fMarkerType(m.fMarkerType),fLineWidth( m.fLineWidth)	fChain(m.fChain), fCindex(m.fCindex),fMarkerType(m.fMarkerType),fLineWidth( m.fLineWidth)

		, fLineOption()
	{}	{}

	//_________________________________________________________	//_________________________________________________________
	inline void TQtMarker::SetColor(Color_t mcolor) { fCindex = mcolor; }	inline void TQtMarker::SetColor(Color_t mcolor) { fCindex = mcolor; }
	//_________________________________________________________	//_________________________________________________________
	inline Color_t TQtMarker::GetColor() const { return fCindex; }	inline Color_t TQtMarker::GetColor() const { return fCindex; }

	#endif	#endif

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

	TStreamerInfo.h	TStreamerInfo.h

	// @(#)root/io:$Id: TStreamerInfo.h 35394 2010-09-17 19:40:12Z pcanal $	// @(#)root/io:$Id: TStreamerInfo.h 36061 2010-10-04 16:05:51Z pcanal $
	// Author: Rene Brun 12/10/2000	// Author: Rene Brun 12/10/2000

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, 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 46	skipping to change at line 46
	class TClass;	class TClass;
	class TClonesArray;	class TClonesArray;
	class TDataMember;	class TDataMember;
	class TMemberStreamer;	class TMemberStreamer;
	class TStreamerElement;	class TStreamerElement;
	class TStreamerBasicType;	class TStreamerBasicType;
	class TClassStreamer;	class TClassStreamer;
	class TVirtualArray;	class TVirtualArray;
	namespace ROOT { class TCollectionProxyInfo; }	namespace ROOT { class TCollectionProxyInfo; }


		namespace TStreamerInfoActions { class TActionSequence; }

	class TStreamerInfo : public TVirtualStreamerInfo {	class TStreamerInfo : public TVirtualStreamerInfo {

	#ifdef R__BROKEN_FUNCTION_TEMPLATES	#ifdef R__BROKEN_FUNCTION_TEMPLATES
	public:	public:
	#endif	#endif
	class TCompInfo {	class TCompInfo {
	// Class used to cache information (see fComp)	// Class used to cache information (see fComp)
	private:	private:
	TCompInfo(const TCompInfo&); // Not implemented	TCompInfo(const TCompInfo&); // Not implemented
	TCompInfo& operator=(const TCompInfo&); // Not implemented	TCompInfo& operator=(const TCompInfo&); // Not implemented

	skipping to change at line 82	skipping to change at line 84
	public:	public:
	TPointerCollectionAdapter( TVirtualCollectionProxy *proxy ):	TPointerCollectionAdapter( TVirtualCollectionProxy *proxy ):
	fProxy( proxy ) {}	fProxy( proxy ) {}

	char* operator[]( UInt_t idx ) const	char* operator[]( UInt_t idx ) const
	{	{
	char el = (char)fProxy->At(idx);	char el = (char)fProxy->At(idx);
	return *el;	return *el;
	}	}
	private:	private:

	TVirtualCollectionProxy *fProxy;	TVirtualCollectionProxy *fProxy;
	};	};

	private:	private:
	UInt_t fCheckSum; //checksum of original class	UInt_t fCheckSum; //checksum of original class
	Int_t fClassVersion; //Class version identifier	Int_t fClassVersion; //Class version identifier
	Int_t fOnFileClassVersion;//!Class version identifier as sto red on file.	Int_t fOnFileClassVersion;//!Class version identifier as sto red on file.
	Int_t fNumber; //!Unique identifier	Int_t fNumber; //!Unique identifier
	Int_t fNdata; //!number of optmized types	Int_t fNdata; //!number of optmized types
	Int_t fSize; //!size of the persistent class	Int_t fSize; //!size of the persistent class
	Int_t *fType; //![fNdata]	Int_t *fType; //![fNdata]

	skipping to change at line 106	skipping to change at line 108
	ULong_t *fElem; //![fNdata]	ULong_t *fElem; //![fNdata]
	ULong_t *fMethod; //![fNdata]	ULong_t *fMethod; //![fNdata]
	TCompInfo *fComp; //![fNdata] additional info	TCompInfo *fComp; //![fNdata] additional info
	TClass *fClass; //!pointer to class	TClass *fClass; //!pointer to class
	TObjArray *fElements; //Array of TStreamerElements	TObjArray *fElements; //Array of TStreamerElements
	Version_t fOldVersion; //! Version of the TStreamerInfo o bject read from the file	Version_t fOldVersion; //! Version of the TStreamerInfo o bject read from the file
	Int_t fNVirtualInfoLoc; //! Number of virtual info locatio n to update.	Int_t fNVirtualInfoLoc; //! Number of virtual info locatio n to update.
	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
		action resulting from the compilation.
		TStreamerInfoActions::TActionSequence *fReadMemberWise; //! List of
		action resulting from the compilation for use in member wise streaming.

	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);	static Double_t GetValueAux(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);


	skipping to change at line 193	skipping to change at line 198
	void ForceWriteInfo(TFile *file, Bool_t force=kFALSE);	void ForceWriteInfo(TFile *file, Bool_t force=kFALSE);
	Int_t GenerateHeaderFile(const char dirname, const TList subClasses = 0, const TList *extrainfos = 0);	Int_t GenerateHeaderFile(const char dirname, const TList subClasses = 0, const TList *extrainfos = 0);
	TClass GetActualClass(const void obj) const;	TClass GetActualClass(const void obj) const;
	TClass *GetClass() const {return fClass;}	TClass *GetClass() const {return fClass;}
	UInt_t GetCheckSum() const {return fCheckSum;}	UInt_t GetCheckSum() const {return fCheckSum;}
	UInt_t GetCheckSum(UInt_t code) const;	UInt_t GetCheckSum(UInt_t code) const;
	Int_t GetClassVersion() const {return fClassVersion;}	Int_t GetClassVersion() const {return fClassVersion;}
	Int_t GetDataMemberOffset(TDataMember dm, TMemberStreamer &streamer) const;	Int_t GetDataMemberOffset(TDataMember dm, TMemberStreamer &streamer) const;
	TObjArray *GetElements() const {return fElements;}	TObjArray *GetElements() const {return fElements;}
	ULong_t *GetElems() const {return fElem;}	ULong_t *GetElems() const {return fElem;}

		TStreamerInfoActions::TActionSequence *GetReadMemberWiseActions(Bool_t f
		orCollection) { return forCollection ? fReadMemberWise : fReadObjectWise; }
		TStreamerInfoActions::TActionSequence *GetReadObjectWiseActions() { retu
		rn fReadObjectWise; }
	Int_t GetNdata() const {return fNdata;}	Int_t GetNdata() const {return fNdata;}
	Int_t GetNumber() const {return fNumber;}	Int_t GetNumber() const {return fNumber;}
	Int_t *GetLengths() const {return fLength;}	Int_t *GetLengths() const {return fLength;}
	ULong_t *GetMethods() const {return fMethod;}	ULong_t *GetMethods() const {return fMethod;}
	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;

	skipping to change at line 231	skipping to change at line 238
	#ifdef R__BROKEN_FUNCTION_TEMPLATES	#ifdef R__BROKEN_FUNCTION_TEMPLATES
	// Support for non standard compilers	// Support for non standard compilers
	Int_t ReadBuffer(TBuffer &b, char** const &arrptr, Int_t first,Int_t narr=1,Int_t eoffset=0,Int_t mode=0);	Int_t ReadBuffer(TBuffer &b, char** const &arrptr, Int_t first,Int_t narr=1,Int_t eoffset=0,Int_t mode=0);
	Int_t ReadBufferSkip(TBuffer &b, char** const &arrptr, Int _t i,Int_t kase, TStreamerElement *aElement, Int_t narr, Int_t eoffset);	Int_t ReadBufferSkip(TBuffer &b, char** const &arrptr, Int _t i,Int_t kase, TStreamerElement *aElement, Int_t narr, Int_t eoffset);
	Int_t ReadBufferConv(TBuffer &b, char** const &arrptr, Int _t i,Int_t kase, TStreamerElement *aElement, Int_t narr, Int_t eoffset);	Int_t ReadBufferConv(TBuffer &b, char** const &arrptr, Int _t i,Int_t kase, TStreamerElement *aElement, Int_t narr, Int_t eoffset);
	Int_t ReadBufferArtificial(TBuffer &b, char** const &arrpt r, Int_t i,Int_t kase, TStreamerElement *aElement, Int_t narr, Int_t eoffse t);	Int_t ReadBufferArtificial(TBuffer &b, char** const &arrpt r, Int_t i,Int_t kase, TStreamerElement *aElement, Int_t narr, Int_t eoffse t);
	Int_t ReadBuffer(TBuffer &b, const TVirtualCollectionProxy &arrptr, Int_t first,Int_t narr=1,Int_t eoffset=0,Int_t mode=0);	Int_t ReadBuffer(TBuffer &b, const TVirtualCollectionProxy &arrptr, Int_t first,Int_t narr=1,Int_t eoffset=0,Int_t mode=0);
	Int_t ReadBufferSkip(TBuffer &b, const TVirtualCollectionP roxy &arrptr, Int_t i,Int_t kase, TStreamerElement *aElement, Int_t narr, I nt_t eoffset);	Int_t ReadBufferSkip(TBuffer &b, const TVirtualCollectionP roxy &arrptr, Int_t i,Int_t kase, TStreamerElement *aElement, Int_t narr, I nt_t eoffset);
	Int_t ReadBufferConv(TBuffer &b, const TVirtualCollectionP roxy &arrptr, Int_t i,Int_t kase, TStreamerElement *aElement, Int_t narr, I nt_t eoffset);	Int_t ReadBufferConv(TBuffer &b, const TVirtualCollectionP roxy &arrptr, Int_t i,Int_t kase, TStreamerElement *aElement, Int_t narr, I nt_t eoffset);
	Int_t ReadBufferArtificial(TBuffer &b, const TVirtualColle ctionProxy &arrptr, Int_t i,Int_t kase, TStreamerElement *aElement, Int_t n arr, Int_t eoffset);	Int_t ReadBufferArtificial(TBuffer &b, const TVirtualColle ctionProxy &arrptr, Int_t i,Int_t kase, TStreamerElement *aElement, Int_t n arr, Int_t eoffset);

	Int_t ReadBuffer(TBuffer &b, const TPointerCollectionAdapt
	er &arrptr, Int_t first,Int_t narr=1,Int_t eoffset=0,Int_t mode=0);
	Int_t ReadBufferSkip(TBuffer &b, const TPointerCollectionA
	dapter &arrptr, Int_t i,Int_t kase, TStreamerElement *aElement, Int_t narr,
	Int_t eoffset);
	Int_t ReadBufferConv(TBuffer &b, const TPointerCollectionA
	dapter &arrptr, Int_t i,Int_t kase, TStreamerElement *aElement, Int_t narr,
	Int_t eoffset);
	Int_t ReadBufferArtificial(TBuffer &b, const TPointerColle
	ctionAdapter &arrptr, Int_t i,Int_t kase, TStreamerElement *aElement, Int_t
	narr, Int_t eoffset);
	Int_t ReadBuffer(TBuffer &b, const TVirtualArray &arrptr, Int_t first,Int_t narr=1,Int_t eoffset=0,Int_t mode=0);	Int_t ReadBuffer(TBuffer &b, const TVirtualArray &arrptr, Int_t first,Int_t narr=1,Int_t eoffset=0,Int_t mode=0);
	Int_t ReadBufferSkip(TBuffer &b, const TVirtualArray &arrp tr, Int_t i,Int_t kase, TStreamerElement *aElement, Int_t narr, Int_t eoffs et);	Int_t ReadBufferSkip(TBuffer &b, const TVirtualArray &arrp tr, Int_t i,Int_t kase, TStreamerElement *aElement, Int_t narr, Int_t eoffs et);
	Int_t ReadBufferConv(TBuffer &b, const TVirtualArray &arrp tr, Int_t i,Int_t kase, TStreamerElement *aElement, Int_t narr, Int_t eoffs et);	Int_t ReadBufferConv(TBuffer &b, const TVirtualArray &arrp tr, Int_t i,Int_t kase, TStreamerElement *aElement, Int_t narr, Int_t eoffs et);
	Int_t ReadBufferArtificial(TBuffer &b, const TVirtualArray &arrptr, Int_t i,Int_t kase, TStreamerElement *aElement, Int_t narr, Int_t eoffset);	Int_t ReadBufferArtificial(TBuffer &b, const TVirtualArray &arrptr, Int_t i,Int_t kase, TStreamerElement *aElement, Int_t narr, Int_t eoffset);
	#else	#else
	template <class T>	template <class T>
	Int_t ReadBuffer(TBuffer &b, const T &arrptr, Int_t first, Int_t narr=1,Int_t eoffset=0,Int_t mode=0);	Int_t ReadBuffer(TBuffer &b, const T &arrptr, Int_t first, Int_t narr=1,Int_t eoffset=0,Int_t mode=0);
	template <class T>	template <class T>
	Int_t ReadBufferSkip(TBuffer &b, const T &arrptr, Int_t i, Int_t kase, TStreamerElement *aElement, Int_t narr, Int_t eoffset);	Int_t ReadBufferSkip(TBuffer &b, const T &arrptr, Int_t i, Int_t kase, TStreamerElement *aElement, Int_t narr, Int_t eoffset);
	template <class T>	template <class T>
	Int_t ReadBufferConv(TBuffer &b, const T &arrptr, Int_t i, Int_t kase, TStreamerElement *aElement, Int_t narr, Int_t eoffset);	Int_t ReadBufferConv(TBuffer &b, const T &arrptr, Int_t i, Int_t kase, TStreamerElement *aElement, Int_t narr, Int_t eoffset);
	template <class T>	template <class T>
	Int_t ReadBufferArtificial(TBuffer &b, const T &arrptr, In t_t i,Int_t kase, TStreamerElement *aElement, Int_t narr, Int_t eoffset);	Int_t ReadBufferArtificial(TBuffer &b, const T &arrptr, In t_t i,Int_t kase, TStreamerElement *aElement, Int_t narr, Int_t eoffset);
	#endif	#endif

	Int_t ReadBufferClones(TBuffer &b, TClonesArray *clones, I nt_t nc, Int_t first, Int_t eoffset);	Int_t ReadBufferClones(TBuffer &b, TClonesArray *clones, I nt_t nc, Int_t first, Int_t eoffset);
	Int_t ReadBufferSTL(TBuffer &b, TVirtualCollectionProxy *c ont, Int_t nc, Int_t first, Int_t eoffset );	Int_t ReadBufferSTL(TBuffer &b, TVirtualCollectionProxy *c ont, Int_t nc, Int_t first, Int_t eoffset );

	Int_t ReadBufferSTLPtrs(TBuffer &b, TVirtualCollectionProx y *cont, Int_t nc, Int_t first, Int_t eoffset );
	void SetCheckSum(UInt_t checksum) {fCheckSum = checksum;}	void SetCheckSum(UInt_t checksum) {fCheckSum = checksum;}
	void SetClass(TClass *cl) {fClass = cl;}	void SetClass(TClass *cl) {fClass = cl;}
	void SetClassVersion(Int_t vers) {fClassVersion=vers;}	void SetClassVersion(Int_t vers) {fClassVersion=vers;}
	void TagFile(TFile *fFile);	void TagFile(TFile *fFile);
	Int_t WriteBuffer(TBuffer &b, char *pointer, Int_t first);	Int_t WriteBuffer(TBuffer &b, char *pointer, Int_t first);
	Int_t WriteBufferClones(TBuffer &b, TClonesArray *clones, Int_t nc, Int_t first, Int_t eoffset);	Int_t WriteBufferClones(TBuffer &b, TClonesArray *clones, Int_t nc, Int_t first, Int_t eoffset);
	Int_t WriteBufferSTL (TBuffer &b, TVirtualCollectionProx y *cont, Int_t nc, Int_t first, Int_t eoffset );	Int_t WriteBufferSTL (TBuffer &b, TVirtualCollectionProx y *cont, Int_t nc, Int_t first, Int_t eoffset );
	Int_t WriteBufferSTLPtrs( TBuffer &b, TVirtualCollectionPr oxy *cont, Int_t nc, Int_t first, Int_t eoffset );	Int_t WriteBufferSTLPtrs( TBuffer &b, TVirtualCollectionPr oxy *cont, Int_t nc, Int_t first, Int_t eoffset );
	virtual void Update(const TClass oldClass, TClass newClass);	virtual void Update(const TClass oldClass, TClass newClass);


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

	TSystem.h	TSystem.h

	// @(#)root/base:$Id: TSystem.h 32406 2010-02-25 12:50:14Z pcanal $	// @(#)root/base:$Id: TSystem.h 37109 2010-11-30 16:30:58Z pcanal $
	// Author: Fons Rademakers 15/09/95	// Author: Fons Rademakers 15/09/95

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, 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 147	skipping to change at line 147

	struct FileStat_t {	struct FileStat_t {
	Long_t fDev; // device id	Long_t fDev; // device id
	Long_t fIno; // inode	Long_t fIno; // inode
	Int_t fMode; // protection (combination of EFileModeMask bits )	Int_t fMode; // protection (combination of EFileModeMask bits )
	Int_t fUid; // user id of owner	Int_t fUid; // user id of owner
	Int_t fGid; // group id of owner	Int_t fGid; // group id of owner
	Long64_t fSize; // total size in bytes	Long64_t fSize; // total size in bytes
	Long_t fMtime; // modification date	Long_t fMtime; // modification date
	Bool_t fIsLink; // symbolic link	Bool_t fIsLink; // symbolic link

		TString fUrl; // end point url of file
	FileStat_t() : fDev(0), fIno(0), fMode(0), fUid(0), fGid(0), fSize(0),	FileStat_t() : fDev(0), fIno(0), fMode(0), fUid(0), fGid(0), fSize(0),

	fMtime(0), fIsLink(kFALSE) { }	fMtime(0), fIsLink(kFALSE), fUrl("") { }
	};	};

	struct UserGroup_t {	struct UserGroup_t {
	Int_t fUid; // user id	Int_t fUid; // user id
	Int_t fGid; // group id	Int_t fGid; // group id
	TString fUser; // user name	TString fUser; // user name
	TString fGroup; // group name	TString fGroup; // group name
	TString fPasswd; // password	TString fPasswd; // password
	TString fRealName; // user full name	TString fRealName; // user full name
	TString fShell; // user preferred shell	TString fShell; // user preferred shell

	skipping to change at line 465	skipping to change at line 466
	//---- System Logging	//---- System Logging
	virtual void Openlog(const char *name, Int_t options, ELogFac ility facility);	virtual void Openlog(const char *name, Int_t options, ELogFac ility facility);
	virtual void Syslog(ELogLevel level, const char *mess);	virtual void Syslog(ELogLevel level, const char *mess);
	virtual void Closelog();	virtual void Closelog();

	//---- Standard Output redirection	//---- Standard Output redirection
	virtual Int_t RedirectOutput(const char name, const char mod e = "a", RedirectHandle_t *h = 0);	virtual Int_t RedirectOutput(const char name, const char mod e = "a", RedirectHandle_t *h = 0);
	virtual void ShowOutput(RedirectHandle_t *h);	virtual void ShowOutput(RedirectHandle_t *h);

	//---- Dynamic Loading	//---- Dynamic Loading

		virtual void AddDynamicPath(const char *pathname);
	virtual const char *GetDynamicPath();	virtual const char *GetDynamicPath();
	virtual void SetDynamicPath(const char *pathname);	virtual void SetDynamicPath(const char *pathname);
	virtual char DynamicPathName(const char lib, Bool_t quiet = kFALSE);	virtual char DynamicPathName(const char lib, Bool_t quiet = kFALSE);
	virtual Func_t DynFindSymbol(const char module, const char en try);	virtual Func_t DynFindSymbol(const char module, const char en try);
	virtual int Load(const char module, const char entry = "", Bool_t system = kFALSE);	virtual int Load(const char module, const char entry = "", Bool_t system = kFALSE);
	virtual void Unload(const char *module);	virtual void Unload(const char *module);
	virtual void ListSymbols(const char module, const char re = "");	virtual void ListSymbols(const char module, const char re = "");
	virtual void ListLibraries(const char *regexp = "");	virtual void ListLibraries(const char *regexp = "");
	virtual const char GetLibraries(const char regexp = "",	virtual const char GetLibraries(const char regexp = "",
	const char *option = "",	const char *option = "",

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

	TTree.h	TTree.h

	// @(#)root/tree:$Id: TTree.h 34969 2010-08-24 19:01:19Z pcanal $	// @(#)root/tree:$Id: TTree.h 37444 2010-12-09 18:12:26Z pcanal $
	// Author: Rene Brun 12/01/96	// Author: Rene Brun 12/01/96

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, 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 185	skipping to change at line 185
	kFindLeaf = BIT(1),	kFindLeaf = BIT(1),
	kGetAlias = BIT(2),	kGetAlias = BIT(2),
	kGetBranch = BIT(3),	kGetBranch = BIT(3),
	kGetEntry = BIT(4),	kGetEntry = BIT(4),
	kGetEntryWithIndex = BIT(5),	kGetEntryWithIndex = BIT(5),
	kGetFriend = BIT(6),	kGetFriend = BIT(6),
	kGetFriendAlias = BIT(7),	kGetFriendAlias = BIT(7),
	kGetLeaf = BIT(8),	kGetLeaf = BIT(8),
	kLoadTree = BIT(9),	kLoadTree = BIT(9),
	kPrint = BIT(10),	kPrint = BIT(10),

	kRemoveFriend = BIT(12),	kRemoveFriend = BIT(11),
	kSetBranchStatus = BIT(12)	kSetBranchStatus = BIT(12)
	};	};

	enum SetBranchAddressStatus {	enum SetBranchAddressStatus {
	kMissingBranch = -5,	kMissingBranch = -5,
	kInternalError = -4,	kInternalError = -4,
	kMissingCompiledCollectionProxy = -3,	kMissingCompiledCollectionProxy = -3,
	kMismatch = -2,	kMismatch = -2,
	kClassMismatch = -1,	kClassMismatch = -1,
	kMatch = 0,	kMatch = 0,

	skipping to change at line 387	skipping to change at line 387
	virtual Long64_t LoadTree(Long64_t entry);	virtual Long64_t LoadTree(Long64_t entry);
	virtual Long64_t LoadTreeFriend(Long64_t entry, TTree* T);	virtual Long64_t LoadTreeFriend(Long64_t entry, TTree* T);
	virtual Int_t MakeClass(const char* classname = 0, Option_t* o ption = "");	virtual Int_t MakeClass(const char* classname = 0, Option_t* o ption = "");
	virtual Int_t MakeCode(const char* filename = 0);	virtual Int_t MakeCode(const char* filename = 0);
	virtual Int_t MakeProxy(const char* classname, const char* mac rofilename = 0, const char* cutfilename = 0, const char* option = 0, Int_t maxUnrolling = 3);	virtual Int_t MakeProxy(const char* classname, const char* mac rofilename = 0, const char* cutfilename = 0, const char* option = 0, Int_t maxUnrolling = 3);
	virtual Int_t MakeSelector(const char* selector = 0);	virtual Int_t MakeSelector(const char* selector = 0);
	Bool_t MemoryFull(Int_t nbytes);	Bool_t MemoryFull(Int_t nbytes);
	virtual Long64_t Merge(TCollection* list, Option_t* option = "");	virtual Long64_t Merge(TCollection* list, Option_t* option = "");
	static TTree MergeTrees(TList list, Option_t* option = "");	static TTree MergeTrees(TList list, Option_t* option = "");
	virtual Bool_t Notify();	virtual Bool_t Notify();

	virtual void OptimizeBaskets(Int_t maxMemory=10000000, Float_ t minComp=1.1, Option_t *option="");	virtual void OptimizeBaskets(ULong64_t maxMemory=10000000, Fl oat_t minComp=1.1, Option_t *option="");
	TPrincipal Principal(const char varexp = "", const char* s election = "", Option_t* option = "np", Long64_t nentries = 1000000000, Lon g64_t firstentry = 0);	TPrincipal Principal(const char varexp = "", const char* s election = "", Option_t* option = "np", Long64_t nentries = 1000000000, Lon g64_t firstentry = 0);
	virtual void Print(Option_t* option = "") const; // MENU	virtual void Print(Option_t* option = "") const; // MENU
	virtual void PrintCacheStats(Option_t* option = "") const;	virtual void PrintCacheStats(Option_t* option = "") const;
	virtual Long64_t Process(const char* filename, Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0); // MENU	virtual Long64_t Process(const char* filename, Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0); // MENU
	#if defined(__CINT__)	#if defined(__CINT__)
	#if defined(R__MANUAL_DICT)	#if defined(R__MANUAL_DICT)
	virtual Long64_t Process(void* selector, Option_t* option = "", L ong64_t nentries = 1000000000, Long64_t firstentry = 0);	virtual Long64_t Process(void* selector, Option_t* option = "", L ong64_t nentries = 1000000000, Long64_t firstentry = 0);
	#endif	#endif
	#else	#else
	virtual Long64_t Process(TSelector* selector, Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0);	virtual Long64_t Process(TSelector* selector, Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0);
	#endif	#endif
	virtual Long64_t Project(const char* hname, const char* varexp, c onst char* selection = "", Option_t* option = "", Long64_t nentries = 10000 00000, Long64_t firstentry = 0);	virtual Long64_t Project(const char* hname, const char* varexp, c onst char* selection = "", Option_t* option = "", Long64_t nentries = 10000 00000, Long64_t firstentry = 0);
	virtual TSQLResult Query(const char varexp = "", const char* selec tion = "", Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0);	virtual TSQLResult Query(const char varexp = "", const char* selec tion = "", Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0);
	virtual Long64_t ReadFile(const char* filename, const char* branc hDescriptor = "");	virtual Long64_t ReadFile(const char* filename, const char* branc hDescriptor = "");

		virtual Long64_t ReadStream(istream& inputStream, const char* bra nchDescriptor = "");
	virtual void Refresh();	virtual void Refresh();
	virtual void RecursiveRemove(TObject *obj);	virtual void RecursiveRemove(TObject *obj);
	virtual void RemoveFriend(TTree*);	virtual void RemoveFriend(TTree*);
	virtual void Reset(Option_t* option = "");	virtual void Reset(Option_t* option = "");
	virtual void ResetBranchAddress(TBranch *);	virtual void ResetBranchAddress(TBranch *);
	virtual void ResetBranchAddresses();	virtual void ResetBranchAddresses();
	virtual Long64_t Scan(const char* varexp = "", const char* select ion = "", Option_t* option = "", Long64_t nentries = 1000000000, Long64_t f irstentry = 0); // MENU	virtual Long64_t Scan(const char* varexp = "", const char* select ion = "", Option_t* option = "", Long64_t nentries = 1000000000, Long64_t f irstentry = 0); // MENU
	virtual Bool_t SetAlias(const char* aliasName, const char* alia sFormula);	virtual Bool_t SetAlias(const char* aliasName, const char* alia sFormula);
	virtual void SetAutoSave(Long64_t autos = 300000000);	virtual void SetAutoSave(Long64_t autos = 300000000);
	virtual void SetAutoFlush(Long64_t autof = 30000000);	virtual void SetAutoFlush(Long64_t autof = 30000000);

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

	TUnfold.h	TUnfold.h

		// @(#)root/hist:$Id: TUnfold.h 37440 2010-12-09 15:13:46Z moneta $
	// Author: Stefan Schmitt	// Author: Stefan Schmitt
	// DESY, 13/10/08	// DESY, 13/10/08


	// Version 15, simplified L-curve scan, new tau definition, new eror calc.	// Version 16, some cleanup, more getter functions, query version number
	//	//
	// History:	// History:

		// Version 15, simplified L-curve scan, new tau definition, new eror cal c.
	// Version 14, with changes in TUnfoldSys.cxx	// Version 14, with changes in TUnfoldSys.cxx
	// Version 13, new methods for derived classes	// Version 13, new methods for derived classes
	// Version 12, with support for preconditioned matrix inversion	// Version 12, with support for preconditioned matrix inversion
	// Version 11, regularisation methods have return values	// Version 11, regularisation methods have return values
	// Version 10, with bug-fix in TUnfold.cxx	// Version 10, with bug-fix in TUnfold.cxx
	// Version 9, implements method for optimized inversion of sparse matrix	// Version 9, implements method for optimized inversion of sparse matrix
	// Version 8, replace all TMatrixSparse matrix operations by private cod e	// Version 8, replace all TMatrixSparse matrix operations by private cod e
	// Version 7, fix problem with TMatrixDSparse,TMatrixD multiplication	// Version 7, fix problem with TMatrixDSparse,TMatrixD multiplication
	// Version 6, completely remove definition of class XY	// Version 6, completely remove definition of class XY
	// Version 5, move definition of class XY from TUnfold.C to this file	// Version 5, move definition of class XY from TUnfold.C to this file

	skipping to change at line 65	skipping to change at line 67

	#include <TH1D.h>	#include <TH1D.h>
	#include <TH2D.h>	#include <TH2D.h>
	#include <TObject.h>	#include <TObject.h>
	#include <TArrayI.h>	#include <TArrayI.h>
	#include <TSpline.h>	#include <TSpline.h>
	#include <TMatrixDSparse.h>	#include <TMatrixDSparse.h>
	#include <TMatrixD.h>	#include <TMatrixD.h>
	#include <TObjArray.h>	#include <TObjArray.h>


		#define TUnfold_VERSION "V16.0"

	class TUnfold : public TObject {	class TUnfold : public TObject {
	private:	private:
	void InitTUnfold(void); // initialize all data members	void InitTUnfold(void); // initialize all data members
	public:	public:
	enum EConstraint {	enum EConstraint {
	kEConstraintNone =0, // use no extra constraint	kEConstraintNone =0, // use no extra constraint
	kEConstraintArea =1 // enforce preservation of the area	kEConstraintArea =1 // enforce preservation of the area
	};	};
	enum ERegMode { // regularisation scheme	enum ERegMode { // regularisation scheme
	kRegModeNone = 0, // no regularisation	kRegModeNone = 0, // no regularisation

	skipping to change at line 96	skipping to change at line 100
	Double_t fTauSquared; // Input: regularisation parameter	Double_t fTauSquared; // Input: regularisation parameter
	Double_t fBiasScale; // Input: scale factor for the bias	Double_t fBiasScale; // Input: scale factor for the bias
	TArrayI fXToHist; // Input: matrix indices -> histogram bins	TArrayI fXToHist; // Input: matrix indices -> histogram bins
	TArrayI fHistToX; // Input: histogram bins -> matrix indices	TArrayI fHistToX; // Input: histogram bins -> matrix indices
	TArrayD fSumOverY; // Input: sum of all columns	TArrayD fSumOverY; // Input: sum of all columns
	EConstraint fConstraint; // Input: type of constraint to use	EConstraint fConstraint; // Input: type of constraint to use
	ERegMode fRegMode; // Input: type of regularisation	ERegMode fRegMode; // Input: type of regularisation
	private:	private:
	TMatrixD *fX; // Result: x	TMatrixD *fX; // Result: x
	TMatrixDSparse *fVxx; // Result: covariance matrix on x	TMatrixDSparse *fVxx; // Result: covariance matrix on x

		TMatrixDSparse *fVxxInv; // Result: inverse of covariance matrix on x
	TMatrixDSparse *fAx; // Result: Ax	TMatrixDSparse *fAx; // Result: Ax
	Double_t fChi2A; // Result: chi**2 contribution from (y-Ax)V (y-Ax)	Double_t fChi2A; // Result: chi**2 contribution from (y-Ax)V (y-Ax)
	Double_t fLXsquared; // Result: chi*2 contribution from (x-sx0 )Lsquared(x-s*x0)	Double_t fLXsquared; // Result: chi*2 contribution from (x-sx0 )Lsquared(x-s*x0)
	Double_t fRhoMax; // Result: maximum global correlation	Double_t fRhoMax; // Result: maximum global correlation
	Double_t fRhoAvg; // Result: average global correlation	Double_t fRhoAvg; // Result: average global correlation
	Int_t fNdf; // Result: number of degrees of freedom	Int_t fNdf; // Result: number of degrees of freedom
	TMatrixDSparse *fDXDAM[2]; // Result: part of derivative dx_k/dA_ij	TMatrixDSparse *fDXDAM[2]; // Result: part of derivative dx_k/dA_ij
	TMatrixDSparse *fDXDAZ[2]; // Result: part of derivative dx_k/dA_ij	TMatrixDSparse *fDXDAZ[2]; // Result: part of derivative dx_k/dA_ij
	TMatrixDSparse *fDXDtauSquared; // Result: derivative dx/dtau	TMatrixDSparse *fDXDtauSquared; // Result: derivative dx/dtau
	TMatrixDSparse *fDXDY; // Result: derivative dx/dy	TMatrixDSparse *fDXDY; // Result: derivative dx/dy

		TMatrixDSparse *fEinv; // Result: matrix E^(-1)
		TMatrixDSparse *fE; // Result: matrix E
	protected:	protected:
	TUnfold(void); // for derived classes	TUnfold(void); // for derived classes
	virtual Double_t DoUnfold(void); // the unfolding algorithm	virtual Double_t DoUnfold(void); // the unfolding algorithm
	virtual void ClearResults(void); // clear all results	virtual void ClearResults(void); // clear all results


	TMatrixDSparse MultiplyMSparseM(TMatrixDSparse const a,TMatrixD const	TMatrixDSparse MultiplyMSparseM(const TMatrixDSparse a,const TMatrixD
	*b) const; // multiply sparse and non-sparse matrix	*b) const; // multiply sparse and non-sparse matrix
	TMatrixDSparse MultiplyMSparseMSparse(TMatrixDSparse const a,TMatrixDS	TMatrixDSparse MultiplyMSparseMSparse(const TMatrixDSparse a,const TMa
	parse const *b) const; // multiply sparse and sparse matrix	trixDSparse *b) const; // multiply sparse and sparse matrix
	TMatrixDSparse MultiplyMSparseTranspMSparse(TMatrixDSparse const a,TMa	TMatrixDSparse MultiplyMSparseTranspMSparse(const TMatrixDSparse a,con
	trixDSparse const *b) const; // multiply transposed sparse and sparse matri	st TMatrixDSparse *b) const; // multiply transposed sparse and sparse matri
	x	x
	TMatrixDSparse *MultiplyMSparseMSparseTranspVector	TMatrixDSparse *MultiplyMSparseMSparseTranspVector

	(TMatrixDSparse const m1,TMatrixDSparse const m2,	(const TMatrixDSparse m1,const TMatrixDSparse m2,
	TMatrixTBase<Double_t> const *v) const; // calculate M_ij = sum_k [m	const TMatrixTBase<Double_t> *v) const; // calculate M_ij = sum_k [m
	1_ikm2_jkv[k] ]. the pointer v may be zero (means no scaling).	1_ikm2_jkv[k] ]. the pointer v may be zero (means no scaling).
	TMatrixD InvertMSparse(TMatrixDSparse const A) const; // invert sparse	TMatrixD InvertMSparse(const TMatrixDSparse A) const; // invert sparse
	matrix	matrix
	static Bool_t InvertMConditioned(TMatrixD *A); // invert matrix includin g preconditioning	static Bool_t InvertMConditioned(TMatrixD *A); // invert matrix includin g preconditioning

	void AddMSparse(TMatrixDSparse dest,Double_t const &f,TMatrixDSparse co nst src); // replacement for dest += f*src	void AddMSparse(TMatrixDSparse dest,Double_t f,const TMatrixDSparse sr c); // replacement for dest += f*src
	TMatrixDSparse CreateSparseMatrix(Int_t nrow,Int_t ncol,Int_t nele,Int_ t row,Int_t col,Double_t data) const; // create a TMatrixDSparse from an array	TMatrixDSparse CreateSparseMatrix(Int_t nrow,Int_t ncol,Int_t nele,Int_ t row,Int_t col,Double_t data) const; // create a TMatrixDSparse from an array
	inline Int_t GetNx(void) const {	inline Int_t GetNx(void) const {
	return fA->GetNcols();	return fA->GetNcols();
	} // number of non-zero output bins	} // number of non-zero output bins
	inline Int_t GetNy(void) const {	inline Int_t GetNy(void) const {
	return fA->GetNrows();	return fA->GetNrows();
	} // number of input bins	} // number of input bins

	void ErrorMatrixToHist(TH2 ematrix,TMatrixDSparse const emat,Int_t con st *binMap,	void ErrorMatrixToHist(TH2 ematrix,const TMatrixDSparse emat,const Int _t *binMap,
	Bool_t doClear) const; // return an error matrix as histogram	Bool_t doClear) const; // return an error matrix as histogram

	inline TMatrixDSparse const *GetDXDY(void) { return fDXDY; } // access d	inline const TMatrixDSparse *GetDXDY(void) const { return fDXDY; } // ac
	erivative dx/dy	cess derivative dx/dy
	inline TMatrixDSparse const *GetDXDAM(int i) { return fDXDAM[i]; } // ac	inline const TMatrixDSparse *GetDXDAM(int i) const { return fDXDAM[i]; }
	cess matrix parts of the derivative dx/dA	// access matrix parts of the derivative dx/dA
	inline TMatrixDSparse const *GetDXDAZ(int i) { return fDXDAZ[i]; } // ac	inline const TMatrixDSparse *GetDXDAZ(int i) const { return fDXDAZ[i]; }
	cess vector parts of the derivative dx/dA	// access vector parts of the derivative dx/dA
	inline TMatrixDSparse const *GetDXDtauSquared(void) { return fDXDtauSqua	inline const TMatrixDSparse *GetDXDtauSquared(void) const { return fDXDt
	red; } // get derivative dx/dtauSquared	auSquared; } // get derivative dx/dtauSquared
	inline TMatrixDSparse const *GetAx(void) { return fAx; } // get vector A	inline const TMatrixDSparse *GetAx(void) const { return fAx; } // get ve
	x	ctor Ax
		inline const TMatrixDSparse *GetEinv(void) const { return fEinv; } // ge
		t matrix E^-1
		inline const TMatrixDSparse *GetE(void) const { return fE; } // get matr
		ix E
		inline const TMatrixDSparse *GetVxx(void) const { return fVxx; } // get
		covariance matrix of x
		inline const TMatrixDSparse *GetVxxInv(void) const { return fVxxInv; } /
		/ get inverse of covariance matrix of x
		inline const TMatrixD *GetX(void) const { return fX; } // get result vec
		tor x
		static void DeleteMatrix(TMatrixD **m); // delete and invalidate pointer
		static void DeleteMatrix(TMatrixDSparse **m); // delete and invalidate p
		ointer
	public:	public:
	enum EHistMap { // mapping between unfolding matrix and TH2 axes	enum EHistMap { // mapping between unfolding matrix and TH2 axes
	kHistMapOutputHoriz = 0, // map unfolding output to x-axis of TH2 ma trix	kHistMapOutputHoriz = 0, // map unfolding output to x-axis of TH2 ma trix
	kHistMapOutputVert = 1 // map unfolding output to y-axis of TH2 ma trix	kHistMapOutputVert = 1 // map unfolding output to y-axis of TH2 ma trix
	};	};


	TUnfold(TH2 const *hist_A, EHistMap histmap,	TUnfold(const TH2 *hist_A, EHistMap histmap,
	ERegMode regmode = kRegModeSize,	ERegMode regmode = kRegModeSize,
	EConstraint constraint=kEConstraintArea); // constructor	EConstraint constraint=kEConstraintArea); // constructor
	virtual ~ TUnfold(void); // delete data members	virtual ~ TUnfold(void); // delete data members

	static void DeleteMatrix(TMatrixD **m); // delete and invalidate pointer	static const char*GetTUnfoldVersion(void);
	static void DeleteMatrix(TMatrixDSparse **m); // delete and invalidate p	void SetBias(const TH1 *bias); // set alternative bias
	ointer
	void SetBias(TH1 const *bias); // set alternative bias
	void SetConstraint(EConstraint constraint); // set type of constraint fo r the next unfolding	void SetConstraint(EConstraint constraint); // set type of constraint fo r the next unfolding

	Int_t RegularizeSize(int bin, Double_t const &scale = 1.0); // regular	Int_t RegularizeSize(int bin, Double_t scale = 1.0); // regularise the
	ise the size of one output bin	size of one output bin
	Int_t RegularizeDerivative(int left_bin, int right_bin, Double_t const &	Int_t RegularizeDerivative(int left_bin, int right_bin, Double_t scale =
	scale = 1.0); // regularize difference of two output bins (1st derivative)	1.0); // regularize difference of two output bins (1st derivative)
	Int_t RegularizeCurvature(int left_bin, int center_bin, int right_bin, D	Int_t RegularizeCurvature(int left_bin, int center_bin, int right_bin, D
	ouble_t const &scale_left = 1.0, Double_t const &scale_right = 1.0); // re	ouble_t scale_left = 1.0, Double_t scale_right = 1.0); // regularize curva
	gularize curvature of three output bins (2nd derivative)	ture of three output bins (2nd derivative)
	Int_t RegularizeBins(int start, int step, int nbin, ERegMode regmode); // regularize a 1-dimensional curve	Int_t RegularizeBins(int start, int step, int nbin, ERegMode regmode); // regularize a 1-dimensional curve
	Int_t RegularizeBins2D(int start_bin, int step1, int nbin1, int step2, i nt nbin2, ERegMode regmode); // regularize a 2-dimensional grid	Int_t RegularizeBins2D(int start_bin, int step1, int nbin1, int step2, i nt nbin2, ERegMode regmode); // regularize a 2-dimensional grid

	Double_t DoUnfold(Double_t const &tau,	Double_t DoUnfold(Double_t tau,
	TH1 const *hist_y, Double_t const &scaleBias=0.0); //	const TH1 *hist_y, Double_t scaleBias=0.0); // do the
	do the unfolding	unfolding
	virtual Int_t SetInput(TH1 const *hist_y, Double_t const &scaleBias=0.0,	virtual Int_t SetInput(const TH1 *hist_y, Double_t scaleBias=0.0,Double_
	Double_t oneOverZeroError=0.0); // define input distribution for ScanLCurve	t oneOverZeroError=0.0); // define input distribution for ScanLCurve
	virtual Double_t DoUnfold(Double_t const &tau); // Unfold with given cho	virtual Double_t DoUnfold(Double_t tau); // Unfold with given choice of
	ice of tau	tau
	virtual Int_t ScanLcurve(Int_t nPoint,Double_t const &tauMin,	virtual Int_t ScanLcurve(Int_t nPoint,Double_t tauMin,
	Double_t const &tauMax,TGraph **lCurve,	Double_t tauMax,TGraph **lCurve,
	TSpline logTauX=0,TSpline logTauY=0); // sca n the L curve using successive calls to DoUnfold(Double_t)	TSpline logTauX=0,TSpline logTauY=0); // sca n the L curve using successive calls to DoUnfold(Double_t)

	TH1D GetOutput(char const name, char const *title, Double_t x0 = 0.0,	TH1D GetOutput(const char name,const char *title, Double_t x0 = 0.0, D
	Double_t x1 = 0.0) const; // get unfolding result	ouble_t x1 = 0.0) const; // get unfolding result
	TH1D GetBias(char const name, char const *title, Double_t x0 = 0.0, Do	TH1D GetBias(const char name,const char *title, Double_t x0 = 0.0, Dou
	uble_t x1 = 0.0) const; // get bias	ble_t x1 = 0.0) const; // get bias
	TH1D GetFoldedOutput(char const name, char const *title, Double_t y0 =	TH1D GetFoldedOutput(const char name,const char *title, Double_t y0 =
	0.0, Double_t y1 = 0.0) const; // get folded unfolding result	0.0, Double_t y1 = 0.0) const; // get folded unfolding result
	TH1D GetInput(char const name, char const *title, Double_t y0 = 0.0, D	TH1D GetInput(const char name,const char *title, Double_t y0 = 0.0, Do
	ouble_t y1 = 0.0) const; // get unfolding input	uble_t y1 = 0.0) const; // get unfolding input
	TH2D GetRhoIJ(char const name, char const *title, Double_t x0 = 0.0, D	TH2D GetRhoIJ(const char name,const char *title, Double_t x0 = 0.0, Do
	ouble_t x1 = 0.0) const; // get correlation coefficients	uble_t x1 = 0.0) const; // get correlation coefficients
	TH2D GetEmatrix(char const name, char const *title, Double_t x0 = 0.0,	TH2D GetEmatrix(const charname,const char *title, Double_t x0 = 0.0, D
	Double_t x1 = 0.0) const; // get error matrix	ouble_t x1 = 0.0) const; // get error matrix
	TH1D GetRhoI(char const name, char const *title, Double_t x0 = 0.0, Do	TH1D GetRhoI(const charname,const char *title, Double_t x0 = 0.0, Doub
	uble_t x1 = 0.0) const; // get global correlation coefficients	le_t x1 = 0.0) const; // get global correlation coefficients
	TH2D GetLsquared(char const name, char const *title, Double_t x0 = 0.0	TH2D GetLsquared(const charname,const char *title, Double_t x0 = 0.0,
	, Double_t x1 = 0.0) const; // get regularisation conditions squared	Double_t x1 = 0.0) const; // get regularisation conditions squared

	void GetOutput(TH1 output,Int_t const binMap=0) const; // get output d	void GetOutput(TH1 output,const Int_t binMap=0) const; // get output d
	istribution, averaged over bins	istribution, averaged over bins
	void GetEmatrix(TH2 ematrix,Int_t const binMap=0) const; // get error	void GetEmatrix(TH2 ematrix,const Int_t binMap=0) const; // get error
	matrix, averaged over bins	matrix, averaged over bins
	Double_t GetRhoI(TH1 rhoi,TH2 ematrixinv=0,Int_t const *binMap=0) cons	Double_t GetRhoI(TH1 rhoi,TH2 ematrixinv=0,const Int_t *binMap=0) cons
	t; // get global correlation coefficients and inverse of error matrix, aver	t; // get global correlation coefficients and inverse of error matrix, aver
	aged over bins	aged over bins
	void GetRhoIJ(TH2 rhoij,Int_t const binMap=0) const; // get correlatio	void GetRhoIJ(TH2 rhoij,const Int_t binMap=0) const; // get correlatio
	n coefficients, averaged over bins	n coefficients, averaged over bins
	Double_t GetTau(void) const; // regularisation parameter	Double_t GetTau(void) const; // regularisation parameter

	Double_t GetRhoMax(void) const; // maximum global correlation	inline Double_t GetRhoMax(void) const { return fRhoMax; } // maximum glo
	Double_t GetRhoAvg(void) const; // average global correlation	bal correlation
	Double_t GetChi2A(void) const; // chi**2 contribution from A	inline Double_t GetRhoAvg(void) const { return fRhoAvg; } // average gl
		obal correlation
		inline Double_t GetChi2A(void) const { return fChi2A; } // chi**2 contr
		ibution from A
	Double_t GetChi2L(void) const; // chi**2 contribution from L	Double_t GetChi2L(void) const; // chi**2 contribution from L
	virtual Double_t GetLcurveX(void) const; // x axis of L curve	virtual Double_t GetLcurveX(void) const; // x axis of L curve
	virtual Double_t GetLcurveY(void) const; // y axis of L curve	virtual Double_t GetLcurveY(void) const; // y axis of L curve

	Int_t GetNdf(void) const; // number of degrees of freedom	inline Int_t GetNdf(void) const { return fNdf; } // number of degrees of freedom
	Int_t GetNpar(void) const; // number of parameters	Int_t GetNpar(void) const; // number of parameters

	ClassDef(TUnfold, 0) //Unfolding with support for L-curve analysis	ClassDef(TUnfold, 0) //Unfolding with support for L-curve analysis
	};	};

	#endif	#endif

End of changes. 18 change blocks.
	76 lines changed or deleted	97 lines changed or added

	TUnfoldSys.h	TUnfoldSys.h

		// @(#)root/hist:$Id: TUnfoldSys.h 37440 2010-12-09 15:13:46Z moneta $
	// Author: Stefan Schmitt	// Author: Stefan Schmitt
	// DESY, 23/01/09	// DESY, 23/01/09


	// Version 15, fix bugs with uncorr. uncertainties, add backgnd subtraction	// Version 16, parallel to changes in TUnfold
	//	//
	// History:	// History:

		// Version 15, fix bugs with uncorr. uncertainties, add backgnd subtrac tion
	// Version 14, with changes in TUnfoldSys.cxx	// Version 14, with changes in TUnfoldSys.cxx
	// Version 13, support for systematic errors	// Version 13, support for systematic errors

	#ifndef ROOT_TUnfoldSys	#ifndef ROOT_TUnfoldSys
	#define ROOT_TUnfoldSys	#define ROOT_TUnfoldSys

	#include <TUnfold.h>	#include <TUnfold.h>

	class TMap;	class TMap;


	skipping to change at line 40	skipping to change at line 42
	TMatrixDSparse *fVyyData; // Input: error on fY prior to bgr subtract ion	TMatrixDSparse *fVyyData; // Input: error on fY prior to bgr subtract ion
	TMatrixDSparse *fEmatUncorrX; // Result: syst.error from fDA2 on fX	TMatrixDSparse *fEmatUncorrX; // Result: syst.error from fDA2 on fX
	TMatrixDSparse *fEmatUncorrAx; // Result: syst.error from fDA2 on fA x	TMatrixDSparse *fEmatUncorrAx; // Result: syst.error from fDA2 on fA x
	TMap *fDeltaCorrX; // Result: syst.shift from fSysIn on fX	TMap *fDeltaCorrX; // Result: syst.shift from fSysIn on fX
	TMap *fDeltaCorrAx; // Result: syst.shift from fSysIn on fAx	TMap *fDeltaCorrAx; // Result: syst.shift from fSysIn on fAx
	TMatrixDSparse *fDeltaSysTau; // Result: systematic shift from tau	TMatrixDSparse *fDeltaSysTau; // Result: systematic shift from tau
	protected:	protected:
	TUnfoldSys(void); // for derived classes	TUnfoldSys(void); // for derived classes
	virtual void ClearResults(void); // clear all results	virtual void ClearResults(void); // clear all results
	virtual void PrepareSysError(void); // common calculations for syst.erro rs	virtual void PrepareSysError(void); // common calculations for syst.erro rs

	virtual TMatrixDSparse PrepareUncorrEmat(TMatrixDSparse const m1,TMatr	virtual TMatrixDSparse PrepareUncorrEmat(const TMatrixDSparse m1,const
	ixDSparse const *m2); // calculate uncorrelated error matrix	TMatrixDSparse *m2); // calculate uncorrelated error matrix
	virtual TMatrixDSparse PrepareCorrEmat(TMatrixDSparse const m1,TMatrix	virtual TMatrixDSparse PrepareCorrEmat(const TMatrixDSparse m1,const T
	DSparse const m2,TMatrixDSparse const dsys); // calculate correlated erro	MatrixDSparse m2,const TMatrixDSparse dsys); // calculate correlated erro
	r matrix	r matrix
	void ScaleColumnsByVector(TMatrixDSparse *m,TMatrixTBase<Double_t> const	void ScaleColumnsByVector(TMatrixDSparse *m,const TMatrixTBase<Double_t>
	*v) const; // scale columns of m by the corresponding rows of v	*v) const; // scale columns of m by the corresponding rows of v
	void VectorMapToHist(TH1 hist_delta,TMatrixDSparse const delta,Int_t c	void VectorMapToHist(TH1 hist_delta,const TMatrixDSparse delta,const I
	onst *binMap); // map and sum vector delta, save in hist_delta	nt_t *binMap); // map and sum vector delta, save in hist_delta
	void GetEmatrixFromVyy(TMatrixDSparse const vyy,TH2 ematrix,Int_t cons	void GetEmatrixFromVyy(const TMatrixDSparse vyy,TH2 ematrix,const Int_
	t *binMap,Bool_t clearEmat); // propagate error matrix vyy to the result	t *binMap,Bool_t clearEmat); // propagate error matrix vyy to the result
	void DoBackgroundSubtraction(void);	void DoBackgroundSubtraction(void);
	public:	public:
	enum ESysErrMode { // meaning of the argument to AddSysError()	enum ESysErrMode { // meaning of the argument to AddSysError()
	kSysErrModeMatrix=0, // matrix is an alternative to the default matrix , the errors are the difference to the original matrix	kSysErrModeMatrix=0, // matrix is an alternative to the default matrix , the errors are the difference to the original matrix
	kSysErrModeShift=1, // matrix gives the absolute shifts	kSysErrModeShift=1, // matrix gives the absolute shifts
	kSysErrModeRelative=2 // matrix gives the relative shifts	kSysErrModeRelative=2 // matrix gives the relative shifts
	};	};

	TUnfoldSys(TH2 const *hist_A, EHistMap histmap, ERegMode regmode = kRegM odeSize,	TUnfoldSys(const TH2 *hist_A, EHistMap histmap, ERegMode regmode = kRegM odeSize,
	EConstraint constraint=kEConstraintNone); // constructor	EConstraint constraint=kEConstraintNone); // constructor
	virtual ~ TUnfoldSys(void); // delete data members	virtual ~ TUnfoldSys(void); // delete data members

	void AddSysError(TH2 const sysError,char const name, EHistMap histmap,	void AddSysError(const TH2 sysError,const char name, EHistMap histmap,
	ESysErrMode mode); // add a systematic error source	ESysErrMode mode); // add a systematic error source

	void GetDeltaSysSource(TH1 hist_delta,char const source,	void GetDeltaSysSource(TH1 hist_delta,const char source,
	Int_t const *binMap=0); // get systematic shifts	const Int_t *binMap=0); // get systematic shifts
	from one systematic source	from one systematic source
	void SubtractBackground(TH1 const hist_bgr,char const name,	void SubtractBackground(const TH1 hist_bgr,const char name,
	Double_t const &scale=1.0,	Double_t scale=1.0,
	Double_t const &scale_error=0.0); // subtract ba	Double_t scale_error=0.0); // subtract backgroun
	ckground prior to unfolding	d prior to unfolding
	virtual Int_t SetInput(TH1 const *hist_y, Double_t const &scaleBias=0.0,	virtual Int_t SetInput(const TH1 *hist_y,Double_t scaleBias=0.0,Double_t
	Double_t oneOverZeroError=0.0); // define input consistently in case of bac	oneOverZeroError=0.0); // define input consistently in case of background
	kground subtraction	subtraction
	void GetDeltaSysBackgroundScale(TH1 delta,char const source,	void GetDeltaSysBackgroundScale(TH1 delta,const char source,
	Int_t const *binMap=0); // get correlated u	const Int_t *binMap=0); // get correlated u
	ncertainty induced by the scale uncertainty of a background source	ncertainty induced by the scale uncertainty of a background source
	void SetTauError(Double_t const &delta_tau); // set uncertainty on tau	void SetTauError(Double_t delta_tau); // set uncertainty on tau
	void GetDeltaSysTau(TH1 delta,Int_t const binMap=0); // get correlated	void GetDeltaSysTau(TH1 delta,const Int_t binMap=0); // get correlated
	uncertainty from varying tau	uncertainty from varying tau
	void GetEmatrixSysUncorr(TH2 ematrix,Int_t const binMap=0,Bool_t clear	void GetEmatrixSysUncorr(TH2 ematrix,const Int_t binMap=0,Bool_t clear
	Emat=kTRUE); // get error matrix contribution from uncorrelated errors on t	Emat=kTRUE); // get error matrix contribution from uncorrelated errors on t
	he matrix A	he matrix A
	void GetEmatrixSysSource(TH2 ematrix,char const source,	void GetEmatrixSysSource(TH2 ematrix,const char source,
	Int_t const *binMap=0,Bool_t clearEmat=kTRUE);	const Int_t *binMap=0,Bool_t clearEmat=kTRUE);
	// get error matrix from one systematic source	// get error matrix from one systematic source
	void GetEmatrixSysBackgroundUncorr(TH2 ematrix,char const source,	void GetEmatrixSysBackgroundUncorr(TH2 ematrix,const char source,
	Int_t const *binMap=0,Bool_t clearEmat=k	const Int_t *binMap=0,Bool_t clearEmat=k
	TRUE); // get error matrix from uncorrelated error of one background source	TRUE); // get error matrix from uncorrelated error of one background source
	void GetEmatrixSysBackgroundScale(TH2 ematrix,char const source,	void GetEmatrixSysBackgroundScale(TH2 ematrix,const char source,
	Int_t const *binMap=0,Bool_t clearEmat=kT	const Int_t *binMap=0,Bool_t clearEmat=kT
	RUE); // get error matrix from the scale error of one background source	RUE); // get error matrix from the scale error of one background source
	void GetEmatrixSysTau(TH2 *ematrix,	void GetEmatrixSysTau(TH2 *ematrix,

	Int_t const *binMap=0,Bool_t clearEmat=kTRUE); // get	const Int_t *binMap=0,Bool_t clearEmat=kTRUE); // get
	error matrix from tau variation	error matrix from tau variation
	void GetEmatrixInput(TH2 ematrix,Int_t const binMap=0,Bool_t clearEmat	void GetEmatrixInput(TH2 ematrix,const Int_t binMap=0,Bool_t clearEmat
	=kTRUE); // get error contribution from input vector	=kTRUE); // get error contribution from input vector
	void GetEmatrixTotal(TH2 ematrix,Int_t const binMap=0); // get total e	void GetEmatrixTotal(TH2 ematrix,const Int_t binMap=0); // get total e
	rror including systematic,statistical,background,tau errors	rror including systematic,statistical,background,tau errors
	Double_t GetChi2Sys(void); // get total chi**2 including all systematic errors	Double_t GetChi2Sys(void); // get total chi**2 including all systematic errors

	ClassDef(TUnfoldSys, 0) //Unfolding with support for systematic error pr opagation	ClassDef(TUnfoldSys, 0) //Unfolding with support for systematic error pr opagation
	};	};

	#endif	#endif

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

	TUnuranSampler.h	TUnuranSampler.h

	// @(#)root/mathcore:$Id: TUnuranSampler.h 34077 2010-06-23 10:09:18Z monet a $	// @(#)root/mathcore:$Id: TUnuranSampler.h 37419 2010-12-08 21:19:45Z monet a $
	// Author: L. Moneta Fri Sep 22 15:06:47 2006	// Author: L. Moneta Fri Sep 22 15:06:47 2006

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/
	// Header file for class TUnuranSampler	// Header file for class TUnuranSampler


	skipping to change at line 69	skipping to change at line 69
	SetFunction<const ROOT::Math::IGenFunction>(func, 1);	SetFunction<const ROOT::Math::IGenFunction>(func, 1);
	}	}

	/// set the Function using a TF1 pointer	/// set the Function using a TF1 pointer
	void SetFunction(TF1 * pdf);	void SetFunction(TF1 * pdf);

	/**	/**
	initialize the generators with the given algorithm	initialize the generators with the given algorithm
	If no algorithm is passed used the default one for the type of distri bution	If no algorithm is passed used the default one for the type of distri bution
	*/	*/

	bool Init(const char * algo =0);	bool Init(const char * algo ="");

		/**
		initialize the generators with the given algorithm
		If no algorithm is passed used the default one for the type of distri
		bution
		*/
		bool Init(const ROOT::Math::DistSamplerOptions & opt );

	/**	/**
	Set the random engine to be used	Set the random engine to be used
	Needs to be called before Init to have effect	Needs to be called before Init to have effect
	*/	*/
	void SetRandom(TRandom * r);	void SetRandom(TRandom * r);

	/**	/**
	Set the random seed for the TRandom instances used by the sampler	Set the random seed for the TRandom instances used by the sampler
	classes	classes
	Needs to be called before Init to have effect	Needs to be called before Init to have effect
	*/	*/
	void SetSeed(unsigned int seed);	void SetSeed(unsigned int seed);


		/**
		Set the print level
		(if level=-1 use default)
		*/
		void SetPrintLevel(int level) {fLevel = level;}

	/*	/*
	set the mode	set the mode
	*/	*/
	void SetMode(double mode) {	void SetMode(double mode) {
	fMode = mode;	fMode = mode;
	fHasMode = true;	fHasMode = true;
	}	}

	/*	/*
	set the area	set the area

	skipping to change at line 148	skipping to change at line 160
	//initialization for multi-dim distributions	//initialization for multi-dim distributions
	bool DoInitND(const char * algo);	bool DoInitND(const char * algo);

	private:	private:

	// private member	// private member
	bool fOneDim; // flag to indicate if t he function is 1 dimension	bool fOneDim; // flag to indicate if t he function is 1 dimension
	bool fDiscrete; // flag to indicate if t he function is discrete	bool fDiscrete; // flag to indicate if t he function is discrete
	bool fHasMode; // flag to indicate if a mode is set	bool fHasMode; // flag to indicate if a mode is set
	bool fHasArea; // flag to indicate if a area is set	bool fHasArea; // flag to indicate if a area is set

		int fLevel; // debug level
	double fMode; // mode of dist	double fMode; // mode of dist
	double fArea; // area of dist	double fArea; // area of dist
	const ROOT::Math::IGenFunction * fFunc1D; // 1D function pointer	const ROOT::Math::IGenFunction * fFunc1D; // 1D function pointer
	TUnuran * fUnuran; // unuran engine class	TUnuran * fUnuran; // unuran engine class

	//ClassDef(TUnuranSampler,1) //Distribution sampler class based on UNU. RAN	//ClassDef(TUnuranSampler,1) //Distribution sampler class based on UNU. RAN

	};	};

	#endif /* ROOT_TUnuranSampler */	#endif /* ROOT_TUnuranSampler */

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

	TVirtualCollectionProxy.h	TVirtualCollectionProxy.h

	// @(#)root/cont:$Id: TVirtualCollectionProxy.h 35298 2010-09-15 12:29:16Z pcanal $	// @(#)root/cont:$Id: TVirtualCollectionProxy.h 36061 2010-10-04 16:05:51Z pcanal $
	// Author: Philippe Canal 20/08/2003	// Author: Philippe Canal 20/08/2003

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2003, Rene Brun, Fons Rademakers and al. *	* Copyright (C) 1995-2003, Rene Brun, Fons Rademakers and al. *
	* 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_TVirtualCollectionProxy	#ifndef ROOT_TVirtualCollectionProxy
	#define Root_TVirtualCollectionProxy	#define ROOT_TVirtualCollectionProxy

	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// //	// //
	// TVirtualCollectionProxy //	// TVirtualCollectionProxy //
	// //	// //
	// Virtual interface of a proxy object for a collection class //	// Virtual interface of a proxy object for a collection class //
	// In particular this is used to implement splitting, emulation, //	// In particular this is used to implement splitting, emulation, //
	// and TTreeFormula access to STL containers. //	// and TTreeFormula access to STL containers. //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////


		#ifndef ROOT_TObject
		#include "TObject.h"
		#endif
	#include "TClassRef.h"	#include "TClassRef.h"
	#include "TDataType.h"	#include "TDataType.h"

	// Macro indicating the version of the Collection Proxy interface followed	// Macro indicating the version of the Collection Proxy interface followed
	// by this ROOT build (See also Reflex/Builder/CollectionProxy.h).	// by this ROOT build (See also Reflex/Builder/CollectionProxy.h).


	#define ROOT_COLLECTIONPROXY_VERSION 2	#define ROOT_COLLECTIONPROXY_VERSION 3

	class TClass;	class TClass;

		namespace TStreamerInfoActions {
		class TActionSequence;
		}

	class TVirtualCollectionProxy {	class TVirtualCollectionProxy {
	private:	private:
	TVirtualCollectionProxy(const TVirtualCollectionProxy&); // Not implemen ted	TVirtualCollectionProxy(const TVirtualCollectionProxy&); // Not implemen ted
	TVirtualCollectionProxy& operator=(const TVirtualCollectionProxy&); // N ot implemented	TVirtualCollectionProxy& operator=(const TVirtualCollectionProxy&); // N ot implemented

	protected:	protected:
	TClassRef fClass;	TClassRef fClass;

		UInt_t fProperties;
	virtual void SetValueClass(TClass *newcl) = 0;	virtual void SetValueClass(TClass *newcl) = 0;
	friend class TClass;	friend class TClass;

	public:	public:

		enum EProperty {
		kIsInitialized = BIT(1),
		kIsAssociative = BIT(2),
		kIsEmulated = BIT(3)
		};

	class TPushPop {	class TPushPop {
	// Helper class that insures that push and pop are done when entering	// Helper class that insures that push and pop are done when entering
	// and leaving a C++ context (even in the presence of exceptions)	// and leaving a C++ context (even in the presence of exceptions)
	public:	public:
	TVirtualCollectionProxy *fProxy;	TVirtualCollectionProxy *fProxy;
	inline TPushPop(TVirtualCollectionProxy *proxy,	inline TPushPop(TVirtualCollectionProxy *proxy,
	void *objectstart) : fProxy(proxy) { fProxy->PushProxy(objectstart ); }	void *objectstart) : fProxy(proxy) { fProxy->PushProxy(objectstart ); }
	inline ~TPushPop() { fProxy->PopProxy(); }	inline ~TPushPop() { fProxy->PopProxy(); }
	private:	private:
	TPushPop(const TPushPop&); // Not implemented	TPushPop(const TPushPop&); // Not implemented
	TPushPop& operator=(const TPushPop&); // Not implemented	TPushPop& operator=(const TPushPop&); // Not implemented
	};	};


	TVirtualCollectionProxy() : fClass() {};	TVirtualCollectionProxy() : fClass(), fProperties(0) {};
	TVirtualCollectionProxy(TClass *cl) : fClass(cl) {};	TVirtualCollectionProxy(TClass *cl) : fClass(cl), fProperties(0) {};

	virtual TVirtualCollectionProxy* Generate() const = 0; // Returns an obj ect of the actual CollectionProxy class	virtual TVirtualCollectionProxy* Generate() const = 0; // Returns an obj ect of the actual CollectionProxy class
	virtual ~TVirtualCollectionProxy() {};	virtual ~TVirtualCollectionProxy() {};

	virtual TClass *GetCollectionClass() { return fClass; } // Return a po inter to the TClass representing the container


	virtual void *New() const { // Return a new container	virtual TClass *GetCollectionClass() { return fClass; }
	object	// Return a pointer to the TClass representing the container
	return fClass.GetClass()==0 ? 0 : fClass->New();
		virtual Int_t GetCollectionType() = 0;
		// Return the type of collection see TClassEdit::ESTLType

		virtual ULong_t GetIncrement() = 0;
		// Return the offset between two consecutive value_types (memory layout)
		.

		virtual Int_t GetProperties() { return fProperties; }
		// Return miscallenous properties of the proxy see TVirtualCollectionPro
		xy::EProperty

		virtual void *New() const {
		// Return a new container object
		return fClass.GetClass()==0 ? 0 : fClass->New();
	}	}

	virtual void New(void arena) const { // Execute the container	virtual void New(void arena) const {
	constructor	// Execute the container constructor
	return fClass.GetClass()==0 ? 0 : fClass->New(arena);	return fClass.GetClass()==0 ? 0 : fClass->New(arena);
	}	}


	virtual void *NewArray(Int_t nElements) const { // Re	virtual void *NewArray(Int_t nElements) const {
	turn a new container object	// Return a new container object
	return fClass.GetClass()==0 ? 0 : fClass->NewArray(nElements);	return fClass.GetClass()==0 ? 0 : fClass->NewArray(nElements);
	}	}

	virtual void NewArray(Int_t nElements, void arena) const { //	virtual void NewArray(Int_t nElements, void arena) const {
	Execute the container constructor	// Execute the container constructor
	return fClass.GetClass()==0 ? 0 : fClass->NewArray(nElements, arena);	return fClass.GetClass()==0 ? 0 : fClass->NewArray(nElements, arena);
	}	}


	virtual void Destructor(void *p, Bool_t dtorOnly = kFALSE) { // Exe	virtual void Destructor(void *p, Bool_t dtorOnly = kFALSE) {
	cute the container destructor	// Execute the container destructor
	TClass* cl = fClass.GetClass();	TClass* cl = fClass.GetClass();
	if (cl) cl->Destructor(p, dtorOnly);	if (cl) cl->Destructor(p, dtorOnly);
	}	}


	virtual void DeleteArray(void *p, Bool_t dtorOnly = kFALSE) { // Ex	virtual void DeleteArray(void *p, Bool_t dtorOnly = kFALSE) {
	ecute the container array destructor	// Execute the container array destructor
	TClass* cl = fClass.GetClass();	TClass* cl = fClass.GetClass();
	if (cl) cl->DeleteArray(p, dtorOnly);	if (cl) cl->DeleteArray(p, dtorOnly);
	}	}


	virtual UInt_t Sizeof() const = 0; // Return the sizeof the collectio	virtual UInt_t Sizeof() const = 0;
	n object.	// Return the sizeof the collection object.

		virtual void PushProxy(void *objectstart) = 0;
		// Set the address of the container being proxied and keep track of the
		previous one.

		virtual void PopProxy() = 0;
		// Reset the address of the container being proxied to the previous cont
		ainer


	virtual void PushProxy(void *objectstart) = 0; // Set the address o	virtual Bool_t HasPointers() const = 0;
	f the container being proxied and keep track of the previous one.	// Return true if the content is of type 'pointer to'
	virtual void PopProxy() = 0; // Reset the address
	of the container being proxied to the previous container


	virtual Bool_t HasPointers() const = 0; // Return true if the content	virtual TClass *GetValueClass() = 0;
	is of type 'pointer to'	// Return a pointer to the TClass representing the content.

		virtual EDataType GetType() = 0;
		// If the content is a simple numerical value, return its type (see TDat
		aType)

		virtual void *At(UInt_t idx) = 0;
		// Return the address of the value at index 'idx'

		virtual void Clear(const char *opt = "") = 0;
		// Clear the container

		virtual UInt_t Size() const = 0;
		// Return the current size of the container


	virtual TClass *GetValueClass() = 0; // Return a pointer to the TC
	lass representing the content.
	virtual EDataType GetType() = 0; // If the content is a simple
	numerical value, return its type (see TDataType)
	virtual void *At(UInt_t idx) = 0; // Return th
	e address of the value at index 'idx'
	virtual void Clear(const char *opt = "") = 0; // Clear the
	container
	virtual UInt_t Size() const = 0; // Return th
	e current size of the container
	virtual void* Allocate(UInt_t n, Bool_t forceDelete) = 0;	virtual void* Allocate(UInt_t n, Bool_t forceDelete) = 0;


	virtual void Commit(void*) = 0;	virtual void Commit(void*) = 0;


	char operator[](UInt_t idx) const { return (char)(const_ca st<TVirtualCollectionProxy*>(this))->At(idx); }	char operator[](UInt_t idx) const { return (char)(const_ca st<TVirtualCollectionProxy*>(this))->At(idx); }


		// MemberWise actions
		virtual TStreamerInfoActions::TActionSequence *GetConversionReadMemberWi
		seActions(TClass *oldClass, Int_t version) = 0;
		virtual TStreamerInfoActions::TActionSequence *GetReadMemberWiseActions(
		Int_t version) = 0;
		virtual TStreamerInfoActions::TActionSequence *GetWriteMemberWiseActions
		() = 0;

		// Set of functions to iterate easily throught the collection
		static const Int_t fgIteratorArenaSize = 16; // greater than sizeof(void
		*) + sizeof(UInt_t)

		typedef void (CreateIterators_t)(void collection, void **begin_arena,
		void **end_arena);
		virtual CreateIterators_t GetFunctionCreateIterators(Bool_t read = kTRUE
		) = 0;
		// begin_arena and end_arena should contain the location of a memory are
		na of size fgIteratorSize.
		// If the collection iterator are of that size or less, the iterators wi
		ll be constructed in place in those location (new with placement)
		// Otherwise the iterators will be allocated via a regular new and their
		address returned by modifying the value of begin_arena and end_arena.

		typedef void* (CopyIterator_t)(void dest, const void *source);
		virtual CopyIterator_t GetFunctionCopyIterator(Bool_t read = kTRUE) = 0;
		// Copy the iterator source, into dest. dest should contain the locati
		on of a memory arena of size fgIteratorSize.
		// If the collection iterator is of that size or less, the iterator will
		be constructed in place in this location (new with placement)
		// Otherwise the iterator will be allocated via a regular new and its ad
		dress returned by modifying the value of dest.

		typedef void* (Next_t)(void iter, const void *end);
		virtual Next_t GetFunctionNext(Bool_t read = kTRUE) = 0;
		// iter and end should be pointers to respectively an iterator to be inc
		remented and the result of collection.end()
		// If the iterator has not reached the end of the collection, 'Next' inc
		rement the iterator 'iter' and return 0 if
		// the iterator reached the end.
		// If the end was not reached, 'Next' returns the address of the content
		pointed to by the iterator before the
		// incrementation ; if the collection contains pointers, 'Next' will ret
		urn the value of the pointer.

		typedef void (DeleteIterator_t)(void iter);
		typedef void (DeleteTwoIterators_t)(void begin, void *end);

		virtual DeleteIterator_t GetFunctionDeleteIterator(Bool_t read = kTRUE)
		= 0;
		virtual DeleteTwoIterators_t GetFunctionDeleteTwoIterators(Bool_t read =
		kTRUE) = 0;
		// If the size of the iterator is greater than fgIteratorArenaSize, call
		delete on the addresses,
		// Otherwise just call the iterator's destructor.

	};	};

	#endif	#endif

End of changes. 22 change blocks.
	45 lines changed or deleted	138 lines changed or added

	TVirtualProofPlayer.h	TVirtualProofPlayer.h

	// @(#)root/proof:$Id: TVirtualProofPlayer.h 33638 2010-05-28 13:13:46Z rdm $	// @(#)root/proof:$Id: TVirtualProofPlayer.h 36592 2010-11-11 10:43:17Z gan is $
	// Author: Fons Rademakers 15/03/07	// Author: Fons Rademakers 15/03/07

	/*************************************************************************	/*************************************************************************
	* 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 48	skipping to change at line 48
	class TMessage;	class TMessage;
	class TProof;	class TProof;
	class TSocket;	class TSocket;
	class TVirtualPacketizer;	class TVirtualPacketizer;
	class TProofProgressStatus;	class TProofProgressStatus;
	class TProofProgressInfo;	class TProofProgressInfo;

	class TVirtualProofPlayer : public TObject, public TQObject {	class TVirtualProofPlayer : public TObject, public TQObject {

	public:	public:

		// TDSet status bits
	enum EExitStatus { kFinished, kStopped, kAborted };	enum EExitStatus { kFinished, kStopped, kAborted };

	TVirtualProofPlayer() { }	TVirtualProofPlayer() { }
	virtual ~TVirtualProofPlayer() { }	virtual ~TVirtualProofPlayer() { }

	virtual Long64_t Process(TDSet *set,	virtual Long64_t Process(TDSet *set,
	const char selector, Option_t option = "",	const char selector, Option_t option = "",
	Long64_t nentries = -1, Long64_t firstentry = 0) = 0;	Long64_t nentries = -1, Long64_t firstentry = 0) = 0;
	virtual Long64_t Finalize(Bool_t force = kFALSE, Bool_t sync = kFALSE) = 0;	virtual Long64_t Finalize(Bool_t force = kFALSE, Bool_t sync = kFALSE) = 0;
	virtual Long64_t Finalize(TQueryResult *qr) = 0;	virtual Long64_t Finalize(TQueryResult *qr) = 0;

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

	TXMLEngine.h	TXMLEngine.h

	// @(#)root/xml:$Id: TXMLEngine.h 32188 2010-02-02 17:41:23Z pcanal $	// @(#)root/xml:$Id: TXMLEngine.h 36517 2010-11-05 14:43:58Z pcanal $
	// Author: Sergey Linev 10.05.2004	// Author: Sergey Linev 10.05.2004

	/*************************************************************************	/*************************************************************************
	* 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 33	skipping to change at line 33

	class TXMLInputStream;	class TXMLInputStream;
	class TXMLOutputStream;	class TXMLOutputStream;
	class TString;	class TString;

	class TXMLEngine : public TObject {	class TXMLEngine : public TObject {

	protected:	protected:
	char* Makestr(const char* str);	char* Makestr(const char* str);
	char* Makenstr(const char* start, int len);	char* Makenstr(const char* start, int len);

	XMLNodePointer_t AllocateNode(const char *name, XMLNodePointer_t parent	XMLNodePointer_t AllocateNode(int namelen, XMLNodePointer_t parent);
	);	XMLAttrPointer_t AllocateAttr(int namelen, int valuelen, XMLNodePointer
	XMLAttrPointer_t AllocateAttr(const char name, const char value, XMLN	_t xmlnode);
	odePointer_t xmlnode);
	XMLAttrPointer_t AllocateAttr(Ssiz_t namelen, Ssiz_t valuelen, XMLNodeP
	ointer_t xmlnode);
	XMLNsPointer_t FindNs(XMLNodePointer_t xmlnode, const char* nsname);	XMLNsPointer_t FindNs(XMLNodePointer_t xmlnode, const char* nsname);
	void TruncateNsExtension(XMLNodePointer_t xmlnode);	void TruncateNsExtension(XMLNodePointer_t xmlnode);
	void UnpackSpecialCharacters(char* target, const char* sour ce, int srclen);	void UnpackSpecialCharacters(char* target, const char* sour ce, int srclen);
	void OutputValue(char* value, TXMLOutputStream* out);	void OutputValue(char* value, TXMLOutputStream* out);
	void SaveNode(XMLNodePointer_t xmlnode, TXMLOutputStream* o ut, Int_t layout, Int_t level);	void SaveNode(XMLNodePointer_t xmlnode, TXMLOutputStream* o ut, Int_t layout, Int_t level);
	XMLNodePointer_t ReadNode(XMLNodePointer_t xmlparent, TXMLInputStream* inp, Int_t& resvalue);	XMLNodePointer_t ReadNode(XMLNodePointer_t xmlparent, TXMLInputStream* inp, Int_t& resvalue);
	void DisplayError(Int_t error, Int_t linenumber);	void DisplayError(Int_t error, Int_t linenumber);
	XMLDocPointer_t ParseStream(TXMLInputStream* input);	XMLDocPointer_t ParseStream(TXMLInputStream* input);

	Bool_t fSkipComments; //! if true, do not create comments nodes in document during parsing	Bool_t fSkipComments; //! if true, do not create comments nodes in document during parsing

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

	Token.h	Token.h

	skipping to change at line 19	skipping to change at line 19
	************************************************************************	************************************************************************
	* Copyright(c) 1995~1999 Masaharu Goto	* Copyright(c) 1995~1999 Masaharu Goto
	*	*
	* For the licensing terms see the file COPYING	* For the licensing terms see the file COPYING
	*	*
	************************************************************************/	************************************************************************/

	#ifndef G__TOKENINFO_H	#ifndef G__TOKENINFO_H
	#define G__TOKENINFO_H	#define G__TOKENINFO_H


		#ifndef G__API_H
	#include "Api.h"	#include "Api.h"

		#endif

	namespace Cint {	namespace Cint {

	class G__ClassInfo;	class G__ClassInfo;
	class G__MethodInfo;	class G__MethodInfo;

	/*********************************************************************	/*********************************************************************
	* class G__TokenInfo	* class G__TokenInfo
	*	*
	* Outcome of discussion between Nenad Buncic of CERN. 15 Mar 1997	* Outcome of discussion between Nenad Buncic of CERN. 15 Mar 1997

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

	Tools.h	Tools.h

	// @(#)root/tmva $Id: Tools.h 35742 2010-09-26 15:56:38Z stelzer $	// @(#)root/tmva $Id: Tools.h 37399 2010-12-08 15:22:07Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : Tools *	* Class : Tools *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Global auxiliary applications and data treatment routines *	* Global auxiliary applications and data treatment routines *

	skipping to change at line 126	skipping to change at line 126
	// parser for TString phrase with items separated by a character	// parser for TString phrase with items separated by a character
	TList* ParseFormatLine( TString theString, const char * sep = ":" );	TList* ParseFormatLine( TString theString, const char * sep = ":" );

	// parse option string for ANN methods	// parse option string for ANN methods
	std::vector<Int_t>* ParseANNOptionString( TString theOptions, Int_t n var,	std::vector<Int_t>* ParseANNOptionString( TString theOptions, Int_t n var,
	std::vector<Int_t>* nodes ) ;	std::vector<Int_t>* nodes ) ;

	// returns the square-root of a symmetric matrix: symMat = sqrtMat*sq rtMat	// returns the square-root of a symmetric matrix: symMat = sqrtMat*sq rtMat
	TMatrixD* GetSQRootMatrix( TMatrixDSym* symMat );	TMatrixD* GetSQRootMatrix( TMatrixDSym* symMat );


		// returns the covariance matrix of of the different classes (and the
		sum)
		// given the event sample
		std::vector<TMatrixDSym> CalcCovarianceMatrices( const std::vector<
		Event*>& events, Int_t maxCls );

	// turns covariance into correlation matrix	// turns covariance into correlation matrix
	const TMatrixD* GetCorrelationMatrix( const TMatrixD* covMat );	const TMatrixD* GetCorrelationMatrix( const TMatrixD* covMat );

	// check spline quality by comparison with initial histogram	// check spline quality by comparison with initial histogram
	Bool_t CheckSplines( const TH1, const TSpline );	Bool_t CheckSplines( const TH1, const TSpline );

	// normalization of variable output	// normalization of variable output
	Double_t NormVariable( Double_t x, Double_t xmin, Double_t xmax );	Double_t NormVariable( Double_t x, Double_t xmin, Double_t xmax );

	// return separation of two histograms	// return separation of two histograms

	skipping to change at line 201	skipping to change at line 205
	enum EWelcomeMessage { kStandardWelcomeMsg = 1,	enum EWelcomeMessage { kStandardWelcomeMsg = 1,
	kIsometricWelcomeMsg,	kIsometricWelcomeMsg,
	kBlockWelcomeMsg,	kBlockWelcomeMsg,
	kLeanWelcomeMsg,	kLeanWelcomeMsg,
	kLogoWelcomeMsg,	kLogoWelcomeMsg,
	kSmall1WelcomeMsg,	kSmall1WelcomeMsg,
	kSmall2WelcomeMsg,	kSmall2WelcomeMsg,
	kOriginalWelcomeMsgColor,	kOriginalWelcomeMsgColor,
	kOriginalWelcomeMsgBW };	kOriginalWelcomeMsgBW };


		// print TMVA citation (to be called from, eg, .TMVAlogon)
		enum ECitation { kPlainText = 1,
		kBibTeX,
		kLaTeX,
		kHtmlLink };

	void TMVAWelcomeMessage();	void TMVAWelcomeMessage();
	void TMVAWelcomeMessage( MsgLogger& logger, EWelcomeMessage m = kStan dardWelcomeMsg );	void TMVAWelcomeMessage( MsgLogger& logger, EWelcomeMessage m = kStan dardWelcomeMsg );
	void TMVAVersionMessage( MsgLogger& logger );	void TMVAVersionMessage( MsgLogger& logger );
	void ROOTVersionMessage( MsgLogger& logger );	void ROOTVersionMessage( MsgLogger& logger );


		void TMVACitation( MsgLogger& logger, ECitation citType = kPlainText
		);

	// string tools	// string tools

	std::vector<TString> SplitString( const TString& theOpt, const char s eparator ) const;	std::vector<TString> SplitString( const TString& theOpt, const char s eparator ) const;

	// variables	// variables
	const TString fRegexp;	const TString fRegexp;
	mutable MsgLogger* fLogger;	mutable MsgLogger* fLogger;
	MsgLogger& Log() const { return *fLogger; }	MsgLogger& Log() const { return *fLogger; }
	static Tools* fgTools;	static Tools* fgTools;


	skipping to change at line 237	skipping to change at line 249
	template<typename T>	template<typename T>
	inline void ReadAttr ( void* node, const char* , T& value );	inline void ReadAttr ( void* node, const char* , T& value );
	void ReadAttr ( void* node, const char* attrname, TString& value );	void ReadAttr ( void* node, const char* attrname, TString& value );
	template<typename T>	template<typename T>
	void AddAttr ( void* node, const char* , const T& value, I nt_t precision = 16 );	void AddAttr ( void* node, const char* , const T& value, I nt_t precision = 16 );
	void AddAttr ( void* node, const char* attrname, const cha r* value );	void AddAttr ( void* node, const char* attrname, const cha r* value );
	void* AddChild ( void* parent, const char* childname, const char* content = 0, bool isRootNode = false );	void* AddChild ( void* parent, const char* childname, const char* content = 0, bool isRootNode = false );
	Bool_t AddRawLine ( void* node, const char * raw );	Bool_t AddRawLine ( void* node, const char * raw );
	Bool_t AddComment ( void* node, const char* comment );	Bool_t AddComment ( void* node, const char* comment );


		void* GetParent( void* child);
	void* GetChild ( void* parent, const char* childname=0 );	void* GetChild ( void* parent, const char* childname=0 );
	void* GetNextChild( void* prevchild, const char* childname=0 );	void* GetNextChild( void* prevchild, const char* childname=0 );
	const char* GetContent ( void* node );	const char* GetContent ( void* node );
	const char* GetName ( void* node );	const char* GetName ( void* node );

	TXMLEngine& xmlengine() { return *fXMLEngine; }	TXMLEngine& xmlengine() { return *fXMLEngine; }
	TXMLEngine* fXMLEngine;	TXMLEngine* fXMLEngine;

	private:	private:

	// utilities for correlation ratio	// utilities for correlation ratio
	Double_t GetYMean_binX( const TH2& , Int_t bin_x );	Double_t GetYMean_binX( const TH2& , Int_t bin_x );

	}; // Common tools	}; // Common tools

	Tools& gTools(); // global accessor	Tools& gTools(); // global accessor

	} // namespace TMVA	} // namespace TMVA

	//_______________________________________________________________________	//_______________________________________________________________________

	// coverity[ -tainted_data_argument : arg-2 ]	template<typename T> void TMVA::Tools::ReadAttr( void* node, const char* at
	template<typename T>	trname, T& value )
	void TMVA::Tools::ReadAttr( void* node, const char* attrname, T& value )
	{	{
	// read attribute from xml	// read attribute from xml
	TString val;	TString val;
	ReadAttr( node, attrname, val );	ReadAttr( node, attrname, val );
	std::stringstream s(val.Data());	std::stringstream s(val.Data());

		// coverity[tainted_data_argument]
	s >> value;	s >> value;
	}	}

	//_______________________________________________________________________	//_______________________________________________________________________
	template<typename T>	template<typename T>
	void TMVA::Tools::AddAttr( void* node, const char* attrname, const T& value , Int_t precision )	void TMVA::Tools::AddAttr( void* node, const char* attrname, const T& value , Int_t precision )
	{	{
	// add attribute to xml	// add attribute to xml
	std::stringstream s;	std::stringstream s;
	s.precision( precision );	s.precision( precision );

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

	ToyMCSampler.h	ToyMCSampler.h

	// @(#)root/roostats:$Id: ToyMCSampler.h 34109 2010-06-24 15:00:16Z moneta $	// @(#)root/roostats:$Id: ToyMCSampler.h 37084 2010-11-29 21:37:13Z moneta $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	// Additions and modifications by Mario Pelliccioni	// Additions and modifications by Mario Pelliccioni
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, 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 23	skipping to change at line 23
	#define ROOSTATS_ToyMCSampler	#define ROOSTATS_ToyMCSampler

	//_________________________________________________	//_________________________________________________
	/*	/*
	BEGIN_HTML	BEGIN_HTML
	<p>	<p>
	ToyMCSampler is an implementation of the TestStatSampler interface.	ToyMCSampler is an implementation of the TestStatSampler interface.
	It generates Toy Monte Carlo for a given parameter point and evaluates a	It generates Toy Monte Carlo for a given parameter point and evaluates a
	TestStatistic.	TestStatistic.
	</p>	</p>


		<p>
		For parallel runs, ToyMCSampler can be given an instance of ProofConfig
		and then run in parallel using proof or proof-lite. Internally, it uses
		ToyMCStudy with the RooStudyManager.
		</p>
	END_HTML	END_HTML
	*/	*/
	//	//

	#ifndef ROOT_Rtypes	#ifndef ROOT_Rtypes
	#include "Rtypes.h"	#include "Rtypes.h"
	#endif	#endif

	#include <vector>	#include <vector>
	#include <sstream>	#include <sstream>

	#include "RooStats/TestStatSampler.h"	#include "RooStats/TestStatSampler.h"
	#include "RooStats/SamplingDistribution.h"	#include "RooStats/SamplingDistribution.h"
	#include "RooStats/TestStatistic.h"	#include "RooStats/TestStatistic.h"
	#include "RooStats/ModelConfig.h"	#include "RooStats/ModelConfig.h"

		#include "RooStats/ProofConfig.h"

	#include "RooWorkspace.h"	#include "RooWorkspace.h"
	#include "RooMsgService.h"	#include "RooMsgService.h"
	#include "RooAbsPdf.h"	#include "RooAbsPdf.h"

		#include "RooRealVar.h"

	#include "RooDataSet.h"	#include "RooDataSet.h"

	namespace RooStats {	namespace RooStats {

	class ToyMCSampler: public TestStatSampler {	class ToyMCSampler: public TestStatSampler {

	public:	public:

		ToyMCSampler() :
		fTestStat(NULL), fSamplingDistName("temp"), fNToys(1)
		{
		// Proof constructor. Do not use.

		fPdf = NULL;
		fPriorNuisance = NULL;
		fNullPOI = NULL;
		fNuisancePars = NULL;
		fObservables = NULL;
		fGlobalObservables = NULL;

		fSize = 0.05;
		fNEvents = 0;
		fGenerateBinned = kFALSE;
		fExpectedNuisancePar = kFALSE;

		fToysInTails = 0.0;
		fMaxToys = RooNumber::infinity();
		fAdaptiveLowLimit = -RooNumber::infinity();
		fAdaptiveHighLimit = RooNumber::infinity();

		fImportanceDensity = NULL;
		fImportanceSnapshot = NULL;
		fProtoData = NULL;

		fProofConfig = NULL;
		}
	ToyMCSampler(TestStatistic &ts, Int_t ntoys) :	ToyMCSampler(TestStatistic &ts, Int_t ntoys) :

	fTestStat(&ts), fSamplingDistName("temp"), fNToys(ntoys)	fTestStat(&ts), fSamplingDistName(ts.GetVarName()), fNToys(ntoys)
	{	{
	fPdf = NULL;	fPdf = NULL;
	fPriorNuisance = NULL;	fPriorNuisance = NULL;
	fNullPOI = NULL;	fNullPOI = NULL;
	fNuisancePars = NULL;	fNuisancePars = NULL;
	fObservables = NULL;	fObservables = NULL;
	fGlobalObservables = NULL;	fGlobalObservables = NULL;

	fSize = 0.05;	fSize = 0.05;
	fNEvents = 0;	fNEvents = 0;
	fGenerateBinned = kFALSE;	fGenerateBinned = kFALSE;
	fExpectedNuisancePar = kFALSE;	fExpectedNuisancePar = kFALSE;


		fToysInTails = 0.0;
		fMaxToys = RooNumber::infinity();
		fAdaptiveLowLimit = -RooNumber::infinity();
		fAdaptiveHighLimit = RooNumber::infinity();

		fImportanceDensity = NULL;
		fImportanceSnapshot = NULL;
		fProtoData = NULL;

		fProofConfig = NULL;
	}	}

	virtual ~ToyMCSampler() {	virtual ~ToyMCSampler() {
	}	}

	// main interface	// main interface
	virtual SamplingDistribution* GetSamplingDistribution(RooArgSet& para mPoint);	virtual SamplingDistribution* GetSamplingDistribution(RooArgSet& para mPoint);


		virtual SamplingDistribution* GetSamplingDistributionSingleWorker(Roo
		ArgSet& paramPoint);

	// generates toy data	// generates toy data
	virtual RooAbsData* GenerateToyData(RooArgSet& /paramPoint/) const;	virtual RooAbsData* GenerateToyData(RooArgSet& /paramPoint/) const;

	// Extended interface to append to sampling distribution more samples	// Extended interface to append to sampling distribution more samples
	virtual SamplingDistribution* AppendSamplingDistribution(RooArgSet& a llParameters,	virtual SamplingDistribution* AppendSamplingDistribution(RooArgSet& a llParameters,
	SamplingDistr ibution* last,	SamplingDistr ibution* last,
	Int_t additio nalMC) {	Int_t additio nalMC) {

	Int_t tmp = fNToys;	Int_t tmp = fNToys;
	fNToys = additionalMC;	fNToys = additionalMC;

	skipping to change at line 107	skipping to change at line 156
	}	}

	virtual TestStatistic* GetTestStatistic() const { return fTestStat; }	virtual TestStatistic* GetTestStatistic() const { return fTestStat; }
	virtual Double_t ConfidenceLevel() const { return 1. - fSize; }	virtual Double_t ConfidenceLevel() const { return 1. - fSize; }
	virtual void Initialize(	virtual void Initialize(
	RooAbsArg& /testStatistic/,	RooAbsArg& /testStatistic/,
	RooArgSet& /paramsOfInterest/,	RooArgSet& /paramsOfInterest/,
	RooArgSet& /nuisanceParameters/	RooArgSet& /nuisanceParameters/
	) {}	) {}


		virtual Int_t GetNToys(void) { return fNToys; }
	virtual void SetNToys(const Int_t ntoy) { fNToys = ntoy; }	virtual void SetNToys(const Int_t ntoy) { fNToys = ntoy; }
	virtual void SetNEventsPerToy(const Int_t nevents) {	virtual void SetNEventsPerToy(const Int_t nevents) {
	// Forces n events even for extended PDFs. Set NEvents=0 to	// Forces n events even for extended PDFs. Set NEvents=0 to
	// use the Poisson distributed events from the extended PDF.	// use the Poisson distributed events from the extended PDF.
	fNEvents = nevents;	fNEvents = nevents;
	}	}

	// specify the values of parameters used when evaluating test statist ic	// specify the values of parameters used when evaluating test statist ic
	virtual void SetParametersForTestStat(const RooArgSet& nullpoi) { fNu llPOI = (RooArgSet*)nullpoi.snapshot(); }	virtual void SetParametersForTestStat(const RooArgSet& nullpoi) { fNu llPOI = (RooArgSet*)nullpoi.snapshot(); }
	// Set the Pdf, add to the the workspace if not already there	// Set the Pdf, add to the the workspace if not already there

	skipping to change at line 135	skipping to change at line 185
	virtual void SetGlobalObservables(const RooArgSet& o) { fGlobalObserv ables = &o; }	virtual void SetGlobalObservables(const RooArgSet& o) { fGlobalObserv ables = &o; }

	// set the size of the test (rate of Type I error) ( Eg. 0.05 for a 9 5% Confidence Interval)	// set the size of the test (rate of Type I error) ( Eg. 0.05 for a 9 5% Confidence Interval)
	virtual void SetTestSize(Double_t size) { fSize = size; }	virtual void SetTestSize(Double_t size) { fSize = size; }
	// set the confidence level for the interval (eg. 0.95 for a 95% Conf idence Interval)	// set the confidence level for the interval (eg. 0.95 for a 95% Conf idence Interval)
	virtual void SetConfidenceLevel(Double_t cl) { fSize = 1. - cl; }	virtual void SetConfidenceLevel(Double_t cl) { fSize = 1. - cl; }

	// Set the TestStatistic (want the argument to be a function of the d ata & parameter points	// Set the TestStatistic (want the argument to be a function of the d ata & parameter points
	virtual void SetTestStatistic(TestStatistic *testStatistic) { fTestSt at = testStatistic; }	virtual void SetTestStatistic(TestStatistic *testStatistic) { fTestSt at = testStatistic; }


	// SetModel does not load the snapshot. Use LoadSnapshot if necessary	virtual void SetExpectedNuisancePar(Bool_t i = kTRUE) { fExpectedNuis
	.	ancePar = i; }
	virtual void SetExpectedNuisancePar(Bool_t i) { fExpectedNuisancePar	virtual void SetAsimovNuisancePar(Bool_t i = kTRUE) { fExpectedNuisan
	= i; cout << "WILL NOT WORK YET" << endl; } // TODO	cePar = i; }
	virtual void SetAsimovNuisancePar(Bool_t i) { fExpectedNuisancePar =
	i; cout << "WILL NOT WORK YET" << endl; } // TODO

	// Checks for sufficient information to do a GetSamplingDistribution( ...).	// Checks for sufficient information to do a GetSamplingDistribution( ...).
	Bool_t CheckConfig(void);	Bool_t CheckConfig(void);

	// control to use bin data generation	// control to use bin data generation
	void SetGenerateBinned(bool binned = true) { fGenerateBinned = binned ; }	void SetGenerateBinned(bool binned = true) { fGenerateBinned = binned ; }

	// Set the name of the sampling distribution used for plotting	// Set the name of the sampling distribution used for plotting
	void SetSamplingDistName(const char* name) { if(name) fSamplingDistNa me = name; }	void SetSamplingDistName(const char* name) { if(name) fSamplingDistNa me = name; }

		string GetSamplingDistName(void) { return fSamplingDistName; }

		// This option forces a maximum number of total toys.
		void SetMaxToys(Double_t t) { fMaxToys = t; }

		void SetToysLeftTail(Double_t toys, Double_t threshold) {
		fToysInTails = toys;
		fAdaptiveLowLimit = threshold;
		fAdaptiveHighLimit = RooNumber::infinity();
		}
		void SetToysRightTail(Double_t toys, Double_t threshold) {
		fToysInTails = toys;
		fAdaptiveHighLimit = threshold;
		fAdaptiveLowLimit = -RooNumber::infinity();
		}
		void SetToysBothTails(Double_t toys, Double_t low_threshold, Double_t
		high_threshold) {
		fToysInTails = toys;
		fAdaptiveHighLimit = high_threshold;
		fAdaptiveLowLimit = low_threshold;
		}

		// for importance sampling, specifies the pdf to sample from
		void SetImportanceDensity(RooAbsPdf *p) { fImportanceDensity = p; }
		// for importance sampling, a snapshot of the parameters used in impo
		rtance density
		void SetImportanceSnapshot(const RooArgSet &s) { fImportanceSnapshot
		= &s; }

		// calling with argument or NULL deactivates proof
		void SetProofConfig(ProofConfig *pc = NULL) { fProofConfig = pc; }

		void SetProtoData(const RooDataSet* d) { fProtoData = d; }

	protected:	protected:


		// helper for GenerateToyData
		RooAbsData* Generate(RooAbsPdf &pdf, RooArgSet &observables, const Ro
		oDataSet *protoData=NULL, int forceEvents=0) const;

	TestStatistic *fTestStat; // test statistic that is being sampled	TestStatistic *fTestStat; // test statistic that is being sampled
	RooAbsPdf *fPdf; // model	RooAbsPdf *fPdf; // model
	string fSamplingDistName; // name of the model	string fSamplingDistName; // name of the model
	RooAbsPdf *fPriorNuisance; // prior pdf for nuisance parameters	RooAbsPdf *fPriorNuisance; // prior pdf for nuisance parameters
	RooArgSet *fNullPOI; // parameters of interest	RooArgSet *fNullPOI; // parameters of interest
	const RooArgSet *fNuisancePars;	const RooArgSet *fNuisancePars;
	const RooArgSet *fObservables;	const RooArgSet *fObservables;
	const RooArgSet *fGlobalObservables;	const RooArgSet *fGlobalObservables;
	Int_t fNToys; // number of toys to generate	Int_t fNToys; // number of toys to generate
	Int_t fNEvents; // number of events per toy (may be ignored depending on settings)	Int_t fNEvents; // number of events per toy (may be ignored depending on settings)
	Double_t fSize;	Double_t fSize;
	Bool_t fExpectedNuisancePar; // whether to use expectation values for nuisance parameters (ie Asimov data set)	Bool_t fExpectedNuisancePar; // whether to use expectation values for nuisance parameters (ie Asimov data set)
	Bool_t fGenerateBinned;	Bool_t fGenerateBinned;


		// minimum no of toys in tails for adaptive sampling
		// (taking weights into account, therefore double)
		// Default: 0.0 which means no adaptive sampling
		Double_t fToysInTails;
		// maximum no of toys
		// (taking weights into account, therefore double)
		Double_t fMaxToys;
		// tails
		Double_t fAdaptiveLowLimit;
		Double_t fAdaptiveHighLimit;

		RooAbsPdf *fImportanceDensity; // in dev
		const RooArgSet *fImportanceSnapshot; // in dev

		const RooDataSet *fProtoData; // in dev

		ProofConfig *fProofConfig; //!

	protected:	protected:
	ClassDef(ToyMCSampler,1) // A simple implementation of the TestStatSampl er interface	ClassDef(ToyMCSampler,1) // A simple implementation of the TestStatSampl er interface
	};	};
	}	}

	#endif	#endif

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

	ToyMCSamplerOld.h	ToyMCSamplerOld.h

	// @(#)root/roostats:$Id: ToyMCSamplerOld.h 35821 2010-09-28 08:18:13Z mone ta $	// @(#)root/roostats:$Id: ToyMCSamplerOld.h 37403 2010-12-08 15:59:22Z mone ta $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	// Additions and modifications by Mario Pelliccioni	// Additions and modifications by Mario Pelliccioni
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, 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. *
	*************************************************************************/	*************************************************************************/


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

	Type.h	Type.h

	skipping to change at line 19	skipping to change at line 19
	************************************************************************	************************************************************************
	* Copyright(c) 1995~2003 Masaharu Goto	* Copyright(c) 1995~2003 Masaharu Goto
	*	*
	* For the licensing terms see the file COPYING	* For the licensing terms see the file COPYING
	*	*
	************************************************************************/	************************************************************************/

	#ifndef G__TYPEINFOX_H	#ifndef G__TYPEINFOX_H
	#define G__TYPEINFOX_H	#define G__TYPEINFOX_H


		#ifndef G__API_H
	#include "Api.h"	#include "Api.h"

		#endif

	namespace Cint {	namespace Cint {

	/*********************************************************************	/*********************************************************************
	* class G__TypeInfo	* class G__TypeInfo
	*	*
	*********************************************************************/	*********************************************************************/
	class	class
	#ifndef __CINT__	#ifndef __CINT__
	G__EXPORT	G__EXPORT

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

	Typedf.h	Typedf.h

	skipping to change at line 19	skipping to change at line 19
	************************************************************************	************************************************************************
	* Copyright(c) 1995~1999 Masaharu Goto	* Copyright(c) 1995~1999 Masaharu Goto
	*	*
	* For the licensing terms see the file COPYING	* For the licensing terms see the file COPYING
	*	*
	************************************************************************/	************************************************************************/

	#ifndef G__TYPEDEFINFO_H	#ifndef G__TYPEDEFINFO_H
	#define G__TYPEDEFINFO_H	#define G__TYPEDEFINFO_H


		#ifndef G__API_H
	#include "Api.h"	#include "Api.h"

		#endif

	namespace Cint {	namespace Cint {

	/*********************************************************************	/*********************************************************************
	* class G__TypedefInfo	* class G__TypedefInfo
	*	*
	*	*
	*********************************************************************/	*********************************************************************/
	class	class
	#ifndef __CINT__	#ifndef __CINT__

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

	Types.h	Types.h

	// @(#)root/tmva $Id: Types.h 35738 2010-09-26 09:17:57Z stelzer $	// @(#)root/tmva $Id: Types.h 37399 2010-12-08 15:22:07Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : Types *	* Class : Types *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* GLobal types (singleton class) *	* GLobal types (singleton class) *

	skipping to change at line 106	skipping to change at line 106
	kMaxMethod	kMaxMethod
	};	};

	// available variable transformations	// available variable transformations
	enum EVariableTransform {	enum EVariableTransform {
	kIdentity = 0,	kIdentity = 0,
	kDecorrelated,	kDecorrelated,
	kNormalized,	kNormalized,
	kPCA,	kPCA,
	kGaussDecorr,	kGaussDecorr,

		kGauss,
		kUniform,
	kMaxVariableTransform	kMaxVariableTransform
	};	};

	// type of analysis	// type of analysis
	enum EAnalysisType {	enum EAnalysisType {
	kClassification = 0,	kClassification = 0,
	kRegression,	kRegression,
	kMulticlass,	kMulticlass,
	kNoAnalysisType,	kNoAnalysisType,
	kMaxAnalysisType	kMaxAnalysisType

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

	VariableDecorrTransform.h	VariableDecorrTransform.h

	// @(#)root/tmva $Id: VariableDecorrTransform.h 31574 2009-12-05 18:23:21Z stelzer $	// @(#)root/tmva $Id: VariableDecorrTransform.h 37399 2010-12-08 15:22:07Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : VariableDecorrTransform *	* Class : VariableDecorrTransform *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Decorrelation of input variables *	* Decorrelation of input variables *

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

	// provides string vector giving explicit transformation	// provides string vector giving explicit transformation
	std::vector<TString>* GetTransformationStrings( Int_t cls ) const;	std::vector<TString>* GetTransformationStrings( Int_t cls ) const;

	private:	private:

	// mutable Event* fTransformedEvent; //! local event copy	// mutable Event* fTransformedEvent; //! local event copy
	std::vector<TMatrixD*> fDecorrMatrices; //! Decorrelation matrix [class0/class1/.../all classes]	std::vector<TMatrixD*> fDecorrMatrices; //! Decorrelation matrix [class0/class1/.../all classes]

	void CalcSQRMats( const std::vector<Event*>&, Int_t maxCls );	void CalcSQRMats( const std::vector<Event*>&, Int_t maxCls );

	std::vector<TMatrixDSym> CalcCovarianceMatrices( const std::vector< Event*>& events, Int_t maxCls );

	ClassDef(VariableDecorrTransform,0) // Variable transformation: decor relation	ClassDef(VariableDecorrTransform,0) // Variable transformation: decor relation
	};	};

	} // namespace TMVA	} // namespace TMVA

	#endif	#endif

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

	Version.h	Version.h

	// @(#)root/tmva $Id: Version.h 33928 2010-06-15 16:19:31Z stelzer $	// @(#)root/tmva $Id: Version.h 37512 2010-12-10 14:19:02Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Fredrik Tegenfeldt, Helge Voss	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Jan Therhaag,
		Eckhard von Toerne, Helge Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : Version *	* Class : Version *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Current TMVA Version - filled automatically during cvs tagging *	* Current TMVA Version - filled automatically during cvs tagging *
	* by python script development/tmvaTag.py *	* by python script development/tmvaTag.py *
	* *	* *
	* Authors (alphabetical): *	* Authors (alphabetical): *

	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerlan
	*	d *
	* Joerg Stelzer <Joerg.Stelzer@cern.ch> - CERN, Switzerland	* Peter Speckmayer <Peter.Speckmayer@cern.ch> - CERN, Switzerlan
	*	d *
	* Fredrik Tegenfeldt <Fredrik.Tegenfeldt@cern.ch> - Iowa State U., US	* Joerg Stelzer <Joerg.Stelzer@cern.ch> - CERN, Switzerlan
	A *	d *
	* Helge Voss <Helge.Voss@cern.ch> - MPI-K Heidelberg,	* Jan Therhaag <therhaag@physik.uni-bonn.de> - U of Bonn, Germa
	GER *	ny *
		* Eckhard v. Toerne <evt@uni-bonn.de> - U of Bonn, Germa
		ny *
		* Helge Voss <Helge.Voss@cern.ch> - MPI-K Heidelberg
		, GER *
	* *	* *

	* Copyright (c) 2007:	* Copyright (c) 2005-2010,
	*	*
	* CERN, Switzerland	* Regents of CERN (Switzerland),
	*	*
	* Iowa State U., USA	* University of Bonn (Germany),
	*	*
	* MPI-K Heidelberg, Germany	* University of Heidelberg (Germany),
	*	*
		* University of Victoria (Canada)
		*
	* *	* *
	* Redistribution and use in source and binary forms, with or without *	* Redistribution and use in source and binary forms, with or without *
	* modification, are permitted according to the terms listed in LICENSE *	* modification, are permitted according to the terms listed in LICENSE *

	* (http://mva.sourceforge.net/license.txt) *	* (http://tmva.sourceforge.net/LICENSE) *
	************************************************************************ ******/	************************************************************************ ******/

	#ifndef ROOT_TMVA_Version	#ifndef ROOT_TMVA_Version
	#define ROOT_TMVA_Version	#define ROOT_TMVA_Version

	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// //	// //
	// Version //	// Version //
	// //	// //
	// Automatically filled by cvs tagger: development/tmvaTag.py //	// Automatically filled by cvs tagger: development/tmvaTag.py //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////


	#define TMVA_RELEASE "4.0.7"	#define TMVA_RELEASE "4.1.0"
	#define TMVA_RELEASE_DATE "Jun 14, 2010"	#define TMVA_RELEASE_DATE "Dec 10, 2010"
	#define TMVA_RELEASE_TIME "17:20:00"	#define TMVA_RELEASE_TIME "15:15:00"
	#define TMVA_VERSION_CODE 262151	#define TMVA_VERSION_CODE 262400
	#define TMVA_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))	#define TMVA_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))

	#endif	#endif

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

	VirtualIntegrator.h	VirtualIntegrator.h

	skipping to change at line 24	skipping to change at line 24
	#define ROOT_Math_VirtualIntegrator	#define ROOT_Math_VirtualIntegrator

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

	#ifndef ROOT_Math_Error	#ifndef ROOT_Math_Error
	#include "Math/Error.h"	#include "Math/Error.h"
	#endif	#endif


		#ifndef ROOT_Math_IntegratorOptions
		#include "Math/IntegratorOptions.h"
		#endif

	#include <vector>	#include <vector>

	namespace ROOT {	namespace ROOT {
	namespace Math {	namespace Math {

	//___________________________________________________________________	//___________________________________________________________________
	/**	/**
	Abstract class for all numerical integration methods (1D and multi-dim)	Abstract class for all numerical integration methods (1D and multi-dim)
	Interface defining the common methods for the	Interface defining the common methods for the
	numerical integrator classes of one and multi dimensions	numerical integrator classes of one and multi dimensions

	skipping to change at line 79	skipping to change at line 83
	/**	/**
	return the estimate of the absolute Error of the last Integral calcul ation	return the estimate of the absolute Error of the last Integral calcul ation
	*/	*/
	virtual double Error() const = 0;	virtual double Error() const = 0;

	/**	/**
	return the Error Status of the last Integral calculation	return the Error Status of the last Integral calculation
	*/	*/
	virtual int Status() const = 0;	virtual int Status() const = 0;


		/**
		return number of function evaluations in calculating the integral
		(if integrator do not implement this function returns -1)
		*/
		virtual int NEval() const { return -1; }

	};	};

	//___________________________________________________________________	//___________________________________________________________________
	/**	/**
	Interface (abstract) class for 1D numerical integration	Interface (abstract) class for 1D numerical integration
	It must be implemented by the concrate Integrator classes like	It must be implemented by the concrate Integrator classes like
	ROOT::Math::GSLIntegrator.	ROOT::Math::GSLIntegrator.
	Plug-in's exist in ROOT to be able to instantiate the derived classes vi a the	Plug-in's exist in ROOT to be able to instantiate the derived classes vi a the
	plug-in manager.	plug-in manager.
	Users should not use directly this class but the concrete classes ROOT:: Math::IntegratorOneDim.	Users should not use directly this class but the concrete classes ROOT:: Math::IntegratorOneDim.

	skipping to change at line 121	skipping to change at line 131

	/// evaluate integral over the (-inf, b)	/// evaluate integral over the (-inf, b)
	virtual double IntegralLow(double b) = 0;	virtual double IntegralLow(double b) = 0;

	/// evaluate integral with singular points	/// evaluate integral with singular points
	virtual double Integral( const std::vector<double> & pts) = 0;	virtual double Integral( const std::vector<double> & pts) = 0;

	/// evaluate Cauchy integral	/// evaluate Cauchy integral
	virtual double IntegralCauchy(double a, double b, double c) = 0;	virtual double IntegralCauchy(double a, double b, double c) = 0;


		/// get the option used for the integration
		/// must be implemented by derived class
		virtual ROOT::Math::IntegratorOneDimOptions Options() const = 0;

		// return type of integrator
		virtual ROOT::Math::IntegrationOneDim::Type Type() const {
		return Options().IntegratorType();
		}

		/// set the options
		/// (should be re-implemented by derived classes -if more options than t
		olerance exist
		virtual void SetOptions(const ROOT::Math::IntegratorOneDimOptions & opt)
		{
		SetRelTolerance(opt.RelTolerance() );
		SetAbsTolerance(opt.AbsTolerance() );
		}

	};	};

	//___________________________________________________________________	//___________________________________________________________________
	/**	/**
	Interface (abstract) class for multi numerical integration	Interface (abstract) class for multi numerical integration
	It must be implemented by the concrete Integrator classes like	It must be implemented by the concrete Integrator classes like
	ROOT::Math::GSLMCIntegrator.	ROOT::Math::GSLMCIntegrator.
	Plug-in's exist in ROOT to be able to instantiate the derived classes vi a the	Plug-in's exist in ROOT to be able to instantiate the derived classes vi a the
	plug-in manager.	plug-in manager.
	Users should not use directly this class but the concrete classes ROOT:: Math::IntegratorMultiDim.	Users should not use directly this class but the concrete classes ROOT:: Math::IntegratorMultiDim.

	skipping to change at line 148	skipping to change at line 174

	/// destructor: no operation	/// destructor: no operation
	virtual ~VirtualIntegratorMultiDim() {}	virtual ~VirtualIntegratorMultiDim() {}

	/// evaluate multi-dim integral	/// evaluate multi-dim integral
	virtual double Integral(const double, const double) = 0;	virtual double Integral(const double, const double) = 0;

	/// setting a multi-dim function	/// setting a multi-dim function
	virtual void SetFunction(const IMultiGenFunction &) = 0;	virtual void SetFunction(const IMultiGenFunction &) = 0;


		/// get the option used for the integration
		/// impelement by derived class otherwise return default ones
		virtual ROOT::Math::IntegratorMultiDimOptions Options() const = 0;

		// return type of integrator
		virtual ROOT::Math::IntegrationMultiDim::Type Type() const {
		return Options().IntegratorType();
		}

		/// set the options (if needed must be re-implemented by derived classes
		)
		virtual void SetOptions(const ROOT::Math::IntegratorMultiDimOptions & op
		t) {
		SetRelTolerance(opt.RelTolerance() );
		SetAbsTolerance(opt.AbsTolerance() );
		}

	};	};

	}//namespace Math	}//namespace Math
	}//namespace ROOT	}//namespace ROOT

	#endif /* ROOT_Math_VirtualIntegrator */	#endif /* ROOT_Math_VirtualIntegrator */

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

	WrappedFunction.h	WrappedFunction.h

	// @(#)root/mathcore:$Id: WrappedFunction.h 33180 2010-04-25 10:14:07Z mone ta $	// @(#)root/mathcore:$Id: WrappedFunction.h 36369 2010-10-19 16:14:31Z mone ta $
	// Authors: L. Moneta, A. Zsenei 08/2005	// Authors: L. Moneta, A. Zsenei 08/2005

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *
	* *	* *
	* This library is free software; you can redistribute it and/or *	* This library is free software; you can redistribute it and/or *
	* modify it under the terms of the GNU General Public License *	* modify it under the terms of the GNU General Public License *
	* as published by the Free Software Foundation; either version 2 *	* as published by the Free Software Foundation; either version 2 *
	* of the License, or (at your option) any later version. *	* of the License, or (at your option) any later version. *

	skipping to change at line 37	skipping to change at line 37

	#ifndef ROOT_Math_IFunction	#ifndef ROOT_Math_IFunction
	#include "IFunction.h"	#include "IFunction.h"
	#endif	#endif

	namespace ROOT {	namespace ROOT {
	namespace Math {	namespace Math {

	struct NullTypeFunc1D {};	struct NullTypeFunc1D {};


	typedef double( * FreeFunctionPtr ) (double );	typedef double(*FreeFunctionPtr)(double);


	typedef double( * FreeMultiFunctionPtr ) (const double *);	typedef double(FreeMultiFunctionPtr)(const double);

	/**	/**
	Template class to wrap any C++ callable object which takes one argument	Template class to wrap any C++ callable object which takes one argument
	i.e. implementing operator() (double x) in a One-dimensional function in terface.	i.e. implementing operator() (double x) in a One-dimensional function in terface.
	It provides a ROOT::Math::IGenFunction-like signature	It provides a ROOT::Math::IGenFunction-like signature

	Note: If you want to wrap just the reference (to avoid copying) you need to use	Note: If you want to wrap just the reference (to avoid copying) you need to use
	Func& or const Func & as template parameter. The former should be used when the	Func& or const Func & as template parameter. The former should be used when the
	operator() is not a const method of Func	operator() is not a const method of Func


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

	WrappedParamFunction.h	WrappedParamFunction.h

	// @(#)root/mathcore:$Id: WrappedParamFunction.h 24482 2008-06-23 15:33:08Z moneta $	// @(#)root/mathcore:$Id: WrappedParamFunction.h 36185 2010-10-08 10:12:18Z rdm $
	// Author: L. Moneta Thu Nov 23 10:38:32 2006	// Author: L. Moneta Thu Nov 23 10:38:32 2006

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for class WrappedParamFunction	// Header file for class WrappedParamFunction

	skipping to change at line 175	skipping to change at line 175
	DoInit();	DoInit();
	}	}

	/// clone the function	/// clone the function
	IMultiGenFunction * Clone() const {	IMultiGenFunction * Clone() const {
	return new WrappedParamFunctionGen(fFunc, fDim, fParams.size() , &fPa rams.front(), &fParIndices.front());	return new WrappedParamFunctionGen(fFunc, fDim, fParams.size() , &fPa rams.front(), &fParIndices.front());
	}	}

	private:	private:
	// copy ctor	// copy ctor

	WrappedParamFunctionGen(const WrappedParamFunctionGen & rhs) {}	WrappedParamFunctionGen(const WrappedParamFunctionGen &); // not impl
	WrappedParamFunctionGen & operator=(const WrappedParamFunctionGen & rhs	emented
	) { return *this;}	WrappedParamFunctionGen & operator=(const WrappedParamFunctionGen &); /
		/ not implemented

	public:	public:

	const double * Parameters() const {	const double * Parameters() const {
	return &(fParams.front());	return &(fParams.front());
	}	}

	void SetParameters(const double * p) {	void SetParameters(const double * p) {
	unsigned int npar = NPar();	unsigned int npar = NPar();
	std::copy(p, p+ npar, fParams.begin() );	std::copy(p, p+ npar, fParams.begin() );

End of changes. 2 change blocks.
	4 lines changed or deleted	5 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 lxbuild147.cern.ch 2.6.18-164.11.1.el5 #1 SMP Wed Jan 20 13:19:07 CET 2010 i686 i686 i386 GNU/Linux"	#define BUILD_NODE "Linux vm-slc5-i686 2.6.18-194.3.1.el5 #1 SMP Fri May 7 16:14:10 CEST 2010 i686 i686 i386 GNU/Linux"
	#define COMPILER "/afs/cern.ch/sw/lcg/contrib/gcc/4.3.2/i686-slc5-gcc34-opt /bin/g++"	#define COMPILER "/afs/cern.ch/sw/lcg/contrib/gcc/4.3.2/i686-slc5-gcc34-opt /bin/g++"
	#define COMPILERVERS "gcc432"	#define COMPILERVERS "gcc432"

	#define MAKESHAREDLIB "cd $BuildDir ; g++ -c $Opt -pipe -m32 -Wall -W -Wov erloaded-virtual -fPIC -pthread $IncludePath $SourceFiles ; g++ $ObjectFil es -shared -Wl,-soname,$LibName.so -m32 -O2 $LinkedLibs -o $SharedLib"	#define MAKESHAREDLIB "cd $BuildDir ; g++ -c $Opt -pipe -m32 -Wall -W -Wov erloaded-virtual -fPIC -pthread $IncludePath $SourceFiles ; g++ $ObjectFile s -shared -Wl,-soname,$LibName.so -m32 -O2 $LinkedLibs -o $SharedLib"
	#define MAKEEXE "cd $BuildDir ; g++ -c -pipe -m32 -Wall -W -Woverloaded-vi rtual -fPIC -pthread $IncludePath $SourceFiles; g++ $ObjectFiles -m32 -O2 -o $ExeName $LinkedLibs -lm -ldl -pthread -rdynamic"	#define MAKEEXE "cd $BuildDir ; g++ -c -pipe -m32 -Wall -W -Woverloaded-vi rtual -fPIC -pthread $IncludePath $SourceFiles; g++ $ObjectFiles -m32 -O2 -o $ExeName $LinkedLibs -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 -lMathCore -lRint "	#define LINKEDLIBS "-L$ROOTSYS/lib -lCore -lCint -lMathCore -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. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	rpderr.h	rpderr.h

	// @(#)root/rpdutils:$Id: rpderr.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/rpdutils:$Id: rpderr.h 36126 2010-10-06 15:14:52Z ganis $
	// Author: Fons Rademakers 11/08/97	// Author: Fons Rademakers 11/08/97

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, 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 28	skipping to change at line 28
	// //	// //
	// This header file defines error codes generated by rootd/proofd. //	// This header file defines error codes generated by rootd/proofd. //
	// NB: In case of change update also strings in net/inc/ErrStr.h //	// NB: In case of change update also strings in net/inc/ErrStr.h //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_NetErrors	#ifndef ROOT_NetErrors
	#include "NetErrors.h"	#include "NetErrors.h"
	#endif	#endif


	typedef void (ErrorHandler_t)(int level, const char msg);	typedef void (ErrorHandler_t)(int level, const char msg, int size);

	#endif	#endif

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

	snprintf.h	snprintf.h

	/* @(#)root/clib:$Id: snprintf.h 35692 2010-09-23 22:14:05Z rdm $ */	/* @(#)root/clib:$Id: snprintf.h 36336 2010-10-13 13:42:06Z rdm $ */
	/* Author: Fons Rademakers 10/12/2000 */	/* Author: Fons Rademakers 10/12/2000 */

	/*	/*
	Write formatted text to buffer 'string', using format string 'format'.	Write formatted text to buffer 'string', using format string 'format'.
	Returns number of characters written, or -1 if truncated.	Returns number of characters written, or -1 if truncated.
	Format string is understood as defined in ANSI C.	Format string is understood as defined in ANSI C.
	*/	*/

	#ifndef ROOT_snprintf	#ifndef ROOT_snprintf
	#define ROOT_snprintf	#define ROOT_snprintf

	#ifndef ROOT_RConfig	#ifndef ROOT_RConfig
	#include "RConfig.h"	#include "RConfig.h"
	#endif	#endif


		#ifndef __CINT__

	#ifdef NEED_SNPRINTF	#ifdef NEED_SNPRINTF

	#include <stdio.h>	#include <stdio.h>
	#include <stdarg.h>	#include <stdarg.h>

	#ifdef __cplusplus	#ifdef __cplusplus
	extern "C" {	extern "C" {
	#endif	#endif

	#ifdef WIN32	#ifdef WIN32

	skipping to change at line 46	skipping to change at line 48
	#ifdef WIN32	#ifdef WIN32
	#pragma warning( pop )	#pragma warning( pop )
	#endif	#endif

	#ifdef __cplusplus	#ifdef __cplusplus
	}	}
	#endif	#endif

	#endif /* NEED_SNPRINTF */	#endif /* NEED_SNPRINTF */


		#else

		int snprintf(char string, size_t length, const char format, ...);

		#endif /* __CINT__ */

	#endif /* ROOT_snprintf */	#endif /* ROOT_snprintf */

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

	strlcpy.h	strlcpy.h

	/* @(#)root/clib:$Id: strlcpy.h 35487 2010-09-20 19:50:18Z pcanal $ */	/* @(#)root/clib:$Id: strlcpy.h 36336 2010-10-13 13:42:06Z rdm $ */
	/* Author: Fons Rademakers 20/9/2010 */	/* Author: Fons Rademakers 20/9/2010 */

	/*	/*
	Inlcude file for strlcpy and strlcat. They are in string.h on systems	Inlcude file for strlcpy and strlcat. They are in string.h on systems
	that have these function (BSD based systems).	that have these function (BSD based systems).
	*/	*/

	#ifndef ROOT_strlcpy	#ifndef ROOT_strlcpy
	#define ROOT_strlcpy	#define ROOT_strlcpy

	#ifndef ROOT_RConfig	#ifndef ROOT_RConfig
	#include "RConfig.h"	#include "RConfig.h"
	#endif	#endif


		#if !defined(__CINT__)

	#ifndef HAS_STRLCPY	#ifndef HAS_STRLCPY

	#ifndef WIN32	#ifndef WIN32
	# include <unistd.h>	# include <unistd.h>
	#elif !defined(__CINT__)	#elif !defined(__CINT__)
	# include <sys/types.h>	# include <sys/types.h>
	#endif	#endif

	#ifdef __cplusplus	#ifdef __cplusplus
	extern "C" {	extern "C" {

	skipping to change at line 37	skipping to change at line 39

	size_t strlcpy(char dst, const char src, size_t siz);	size_t strlcpy(char dst, const char src, size_t siz);
	size_t strlcat(char dst, const char src, size_t siz);	size_t strlcat(char dst, const char src, size_t siz);

	#ifdef __cplusplus	#ifdef __cplusplus
	}	}
	#endif	#endif

	#endif /* HAS_STRLCPY */	#endif /* HAS_STRLCPY */


		#else

		size_t strlcpy(char dst, const char src, size_t siz);
		size_t strlcat(char dst, const char src, size_t siz);

		#endif /* __CINT__ */

	#endif /* ROOT_strlcpy */	#endif /* ROOT_strlcpy */

End of changes. 3 change blocks.
	1 lines changed or deleted	10 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/

	BayesianCalculator.h	BayesianCalculator.h

	// @(#)root/roostats:$Id: BayesianCalculator.h 35056 2010-08-27 20:03:18Z m oneta $	// @(#)root/roostats:$Id: BayesianCalculator.h 37084 2010-11-29 21:37:13Z m oneta $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, 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 ROOSTATS_BayesianCalculator	#ifndef ROOSTATS_BayesianCalculator

	skipping to change at line 114	skipping to change at line 114
	void SetBrfPrecision( double precision ) { fBrfPrecision = precision; }	void SetBrfPrecision( double precision ) { fBrfPrecision = precision; }

	// use directly the approximate posterior function obtained by binnin g it in nbins	// use directly the approximate posterior function obtained by binnin g it in nbins
	// by default the cdf is used by integrating the posterior	// by default the cdf is used by integrating the posterior
	// if a value of nbin <= 0 the cdf function will be used	// if a value of nbin <= 0 the cdf function will be used
	void SetScanOfPosterior(int nbin = 100) { fNScanBins = nbin; }	void SetScanOfPosterior(int nbin = 100) { fNScanBins = nbin; }

	// set the integration type (possible type are)	// set the integration type (possible type are)
	// 1D: adaptive, gauss, nonadaptive	// 1D: adaptive, gauss, nonadaptive
	// multidim: adaptive, vegas, miser, plain. These last 3 are based on MC integration	// multidim: adaptive, vegas, miser, plain. These last 3 are based on MC integration

		// if type = 0 use default specified via class IntegratorMultiDimOpti ons::SetDefaultIntegrator
	void SetIntegrationType(const char * type);	void SetIntegrationType(const char * type);

	// return the mode (most probable value of the posterior function)	// return the mode (most probable value of the posterior function)
	double GetMode() const;	double GetMode() const;

	protected:	protected:

	void ClearAll() const;	void ClearAll() const;

	void ApproximatePosterior() const;	void ApproximatePosterior() const;

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

	BinaryTree.h	BinaryTree.h

	// @(#)root/tmva $Id: BinaryTree.h 33928 2010-06-15 16:19:31Z stelzer $	// @(#)root/tmva $Id: BinaryTree.h 37399 2010-12-08 15:22:07Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : BinaryTree *	* Class : BinaryTree *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* BinaryTree: A base class for BinarySearch- or Decision-Trees *	* BinaryTree: A base class for BinarySearch- or Decision-Trees *

	skipping to change at line 80	skipping to change at line 80

	public:	public:

	// or a tree with Root node "n", any daughters of this node are autom atically in the tree	// or a tree with Root node "n", any daughters of this node are autom atically in the tree
	BinaryTree( void );	BinaryTree( void );

	virtual ~BinaryTree();	virtual ~BinaryTree();

	virtual Node* CreateNode(UInt_t size=0) const = 0;	virtual Node* CreateNode(UInt_t size=0) const = 0;
	virtual BinaryTree* CreateTree() const = 0;	virtual BinaryTree* CreateTree() const = 0;

	static BinaryTree* CreateFromXML(void* node, UInt_t tmva_Version_Cod e = TMVA_VERSION_CODE);	// virtual BinaryTree* CreateFromXML(void* node, UInt_t tmva_Ver sion_Code = TMVA_VERSION_CODE) = 0;
	virtual const char* ClassName() const = 0;	virtual const char* ClassName() const = 0;

	// set the root node of the tree	// set the root node of the tree
	void SetRoot( Node* r ) { fRoot = r; }	void SetRoot( Node* r ) { fRoot = r; }

	// Retrieves the address of the root node	// Retrieves the address of the root node

	Node* GetRoot() const { return fRoot; }	virtual Node* GetRoot() const { return fRoot; }

	// get number of Nodes in the Tree as counted while booking the nodes ;	// get number of Nodes in the Tree as counted while booking the nodes ;
	UInt_t GetNNodes() const { return fNNodes; }	UInt_t GetNNodes() const { return fNNodes; }

	// count the number of Nodes in the Tree by looping through the tree and updates	// count the number of Nodes in the Tree by looping through the tree and updates
	// the stored number. (e.g. useful when pruning, as the number count is updated when	// the stored number. (e.g. useful when pruning, as the number count is updated when
	// building the tree.	// building the tree.
	UInt_t CountNodes( Node* n = NULL );	UInt_t CountNodes( Node* n = NULL );

	UInt_t GetTotalTreeDepth() const { return fDepth; }	UInt_t GetTotalTreeDepth() const { return fDepth; }

	skipping to change at line 112	skipping to change at line 112
	Node* GetLeftDaughter ( Node* n);	Node* GetLeftDaughter ( Node* n);
	Node* GetRightDaughter( Node* n);	Node* GetRightDaughter( Node* n);

	virtual void Print( ostream& os ) const;	virtual void Print( ostream& os ) const;
	virtual void Read ( istream& istr, UInt_t tmva_Version_Code = TMVA_VE RSION_CODE );	virtual void Read ( istream& istr, UInt_t tmva_Version_Code = TMVA_VE RSION_CODE );
	virtual void* AddXMLTo(void* parent) const;	virtual void* AddXMLTo(void* parent) const;
	virtual void ReadXML(void* node, UInt_t tmva_Version_Code = TMVA_VER SION_CODE );	virtual void ReadXML(void* node, UInt_t tmva_Version_Code = TMVA_VER SION_CODE );

	private:	private:


		protected:
	Node* fRoot; //the root node of the tree	Node* fRoot; //the root node of the tree
	// the tree only has it's root node, the "daughters" are taken car	// the tree only has it's root node, the "daughters" are taken car
	// of by the "node" properties of the "root"	// of by the "node" properties of the "root"


	protected:

	// delete a node (and the corresponding event if owned by the tree)	// delete a node (and the corresponding event if owned by the tree)
	void DeleteNode( Node* );	void DeleteNode( Node* );

	UInt_t fNNodes; // total number of nodes in the tree (c ounted)	UInt_t fNNodes; // total number of nodes in the tree (c ounted)
	UInt_t fDepth; // maximal depth in tree reached	UInt_t fDepth; // maximal depth in tree reached

	static MsgLogger* fgLogger; // message logger, static to save resou rces	static MsgLogger* fgLogger; // message logger, static to save resou rces
	MsgLogger& Log() const { return *fgLogger; }	MsgLogger& Log() const { return *fgLogger; }

	ClassDef(BinaryTree,0) // Base class for BinarySearch and Decision Tr ees	ClassDef(BinaryTree,0) // Base class for BinarySearch and Decision Tr ees

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

	BrentMinimizer1D.h	BrentMinimizer1D.h

	// @(#)root/mathcore:$Id: BrentMinimizer1D.h 32583 2010-03-12 09:57:42Z mon eta $	// @(#)root/mathcore:$Id: BrentMinimizer1D.h 36905 2010-11-24 15:44:34Z mon eta $
	// Author: David Gonzalez Maline 2/2008	// Author: David Gonzalez Maline 2/2008
	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2004 Maline, CERN/PH-SFT *	* Copyright (c) 2004 Maline, CERN/PH-SFT *
	* *	* *
	* This library is free software; you can redistribute it and/or *	* This library is free software; you can redistribute it and/or *
	* modify it under the terms of the GNU General Public License *	* modify it under the terms of the GNU General Public License *
	* as published by the Free Software Foundation; either version 2 *	* as published by the Free Software Foundation; either version 2 *
	* of the License, or (at your option) any later version. *	* of the License, or (at your option) any later version. *
	* *	* *

	skipping to change at line 129	skipping to change at line 129

	\@param f Function to be minimized.	\@param f Function to be minimized.
	\@param xlow Lower bound of the search interval.	\@param xlow Lower bound of the search interval.
	\@param xup Upper bound of the search interval.	\@param xup Upper bound of the search interval.
	*/	*/
	void SetFunction(const ROOT::Math::IGenFunction& f, double xlow, doub le xup);	void SetFunction(const ROOT::Math::IGenFunction& f, double xlow, doub le xup);

	/** Set the number of point used to bracket root using a grid */	/** Set the number of point used to bracket root using a grid */
	void SetNpx(int npx) { fNpx = npx; }	void SetNpx(int npx) { fNpx = npx; }


		/**
		Set a log grid scan (default is equidistant bins)
		will work only if xlow > 0
		*/
		void SetLogScan(bool on) { fLogScan = on; }

	/** Returns status of last estimate. If = 0 is OK */	/** Returns status of last estimate. If = 0 is OK */
	int Status() const { return fStatus; }	int Status() const { return fStatus; }

	// static function used to modify the default parameters	// static function used to modify the default parameters

	/** set number of default Npx used at construction time (when SetNpx is not called)	/** set number of default Npx used at construction time (when SetNpx is not called)
	Default value is 100	Default value is 100
	*/	*/
	static void SetDefaultNpx(int npx);	static void SetDefaultNpx(int npx);

	/** set number of times the bracketing search in combination with is done to find a good interval	/** set number of times the bracketing search in combination with is done to find a good interval
	Default value is 10	Default value is 10
	*/	*/
	static void SetDefaultNSearch(int n);	static void SetDefaultNSearch(int n);

	private:	private:

	const IGenFunction* fFunction; // Pointer to the function.	const IGenFunction* fFunction; // Pointer to the function.

		bool fLogScan; // flag to control usage of a log scan
	int fNIter; // Number of iterations needed for the last estimation.	int fNIter; // Number of iterations needed for the last estimation.
	int fNpx; // Number of points to bracket minimum with grid (def is 100)	int fNpx; // Number of points to bracket minimum with grid (def is 100)
	int fStatus; // Status of code of the last estimate	int fStatus; // Status of code of the last estimate
	double fXMin; // Lower bound of the search interval.	double fXMin; // Lower bound of the search interval.
	double fXMax; // Upper bound of the search interval	double fXMax; // Upper bound of the search interval
	double fXMinimum; // Position of the stimated minimum.	double fXMinimum; // Position of the stimated minimum.

	}; // end class BrentMinimizer1D	}; // end class BrentMinimizer1D

	} // end namespace Math	} // end namespace Math

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

	BrentRootFinder.h	BrentRootFinder.h

	// @(#)root/mathcore:$Id: BrentRootFinder.h 32583 2010-03-12 09:57:42Z mone ta $	// @(#)root/mathcore:$Id: BrentRootFinder.h 36905 2010-11-24 15:44:34Z mone ta $
	// Authors: David Gonzalez Maline 01/2008	// Authors: David Gonzalez Maline 01/2008

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 , LCG ROOT MathLib Team *	* Copyright (c) 2006 , LCG ROOT MathLib Team *
	* *	* *
	* This library is free software; you can redistribute it and/or *	* This library is free software; you can redistribute it and/or *
	* modify it under the terms of the GNU General Public License *	* modify it under the terms of the GNU General Public License *
	* as published by the Free Software Foundation; either version 2 *	* as published by the Free Software Foundation; either version 2 *
	* of the License, or (at your option) any later version. *	* of the License, or (at your option) any later version. *

	skipping to change at line 102	skipping to change at line 102

	\@param maxIter maximum number of iterations.	\@param maxIter maximum number of iterations.
	\@param absTol desired absolute error in the minimum position.	\@param absTol desired absolute error in the minimum position.
	\@param absTol desired relative error in the minimum position.	\@param absTol desired relative error in the minimum position.
	*/	*/
	bool Solve(int maxIter = 100, double absTol = 1E-8, double relTol = 1 E-10);	bool Solve(int maxIter = 100, double absTol = 1E-8, double relTol = 1 E-10);

	/** Set the number of point used to bracket root using a grid */	/** Set the number of point used to bracket root using a grid */
	void SetNpx(int npx) { fNpx = npx; }	void SetNpx(int npx) { fNpx = npx; }


		/**
		Set a log grid scan (default is equidistant bins)
		will work only if xlow > 0
		*/
		void SetLogScan(bool on) { fLogScan = on; }

	/** Returns root value. Need to call first Solve(). */	/** Returns root value. Need to call first Solve(). */
	double Root() const { return fRoot; }	double Root() const { return fRoot; }

	/** Returns status of last estimate. If = 0 is OK */	/** Returns status of last estimate. If = 0 is OK */
	int Status() const { return fStatus; }	int Status() const { return fStatus; }

	/** Return number of iteration used to find minimum */	/** Return number of iteration used to find minimum */
	int Iterations() const { return fNIter; }	int Iterations() const { return fNIter; }

	/** Return name of root finder algorithm ("BrentRootFinder"). */	/** Return name of root finder algorithm ("BrentRootFinder"). */

	skipping to change at line 129	skipping to change at line 135
	static void SetDefaultNpx(int npx);	static void SetDefaultNpx(int npx);

	/** set number of times the bracketing search in combination with is done to find a good interval	/** set number of times the bracketing search in combination with is done to find a good interval
	Default value is 10	Default value is 10
	*/	*/
	static void SetDefaultNSearch(int n);	static void SetDefaultNSearch(int n);

	private:	private:

	const IGenFunction* fFunction; // Pointer to the function.	const IGenFunction* fFunction; // Pointer to the function.

		bool fLogScan; // flag to control usage of a log scan
	int fNIter; // Number of iterations needed for the last estimation.	int fNIter; // Number of iterations needed for the last estimation.
	int fNpx; // Number of points to bracket root wi th initial grid (def is 100)	int fNpx; // Number of points to bracket root wi th initial grid (def is 100)
	int fStatus; // Status of code of the last estimate	int fStatus; // Status of code of the last estimate
	double fXMin; // Lower bound of the search interval.	double fXMin; // Lower bound of the search interval.
	double fXMax; // Upper bound of the search interval	double fXMax; // Upper bound of the search interval
	double fRoot; // Current stimation of the function r oot.	double fRoot; // Current stimation of the function r oot.
	};	};

	} // namespace Math	} // namespace Math
	} // namespace ROOT	} // namespace ROOT

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

	Chi2FCN.h	Chi2FCN.h

	// @(#)root/mathcore:$Id: Chi2FCN.h 30539 2009-10-01 13:13:09Z moneta $	// @(#)root/mathcore:$Id: Chi2FCN.h 37232 2010-12-03 18:09:43Z moneta $
	// Author: L. Moneta Tue Sep 5 09:13:32 2006	// Author: L. Moneta Tue Sep 5 09:13:32 2006

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for class Chi2FCN	// Header file for class Chi2FCN

	skipping to change at line 124	skipping to change at line 124
	return fcn;	return fcn;
	}	}

	using BaseObjFunction::operator();	using BaseObjFunction::operator();

	// effective points used in the fit (exclude the rejected one)	// effective points used in the fit (exclude the rejected one)
	virtual unsigned int NFitPoints() const { return fNEffPoints; }	virtual unsigned int NFitPoints() const { return fNEffPoints; }

	/// i-th chi-square residual	/// i-th chi-square residual
	virtual double DataElement(const double * x, unsigned int i, double * g) const {	virtual double DataElement(const double * x, unsigned int i, double * g) const {

		if (i==0) this->UpdateNCalls();
	return FitUtil::EvaluateChi2Residual(fFunc, fData, x, i, g);	return FitUtil::EvaluateChi2Residual(fFunc, fData, x, i, g);
	}	}

	// need to be virtual to be instantited	// need to be virtual to be instantited
	virtual void Gradient(const double x, double g) const {	virtual void Gradient(const double x, double g) const {
	// evaluate the chi2 gradient	// evaluate the chi2 gradient
	FitUtil::EvaluateChi2Gradient(fFunc, fData, x, g, fNEffPoints);	FitUtil::EvaluateChi2Gradient(fFunc, fData, x, g, fNEffPoints);
	}	}

	/// get type of fit method function	/// get type of fit method function

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

	ConfidenceBelt.h	ConfidenceBelt.h

	// @(#)root/roostats:$Id: ConfidenceBelt.h 35821 2010-09-28 08:18:13Z monet a $	// @(#)root/roostats:$Id: ConfidenceBelt.h 36024 2010-10-01 16:03:30Z monet a $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, 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 RooStats_ConfidenceBelt	#ifndef RooStats_ConfidenceBelt

	skipping to change at line 103	skipping to change at line 103
	private:	private:
	LookupTable fLookupTable; // map ( Index, ( CL, leftside tail prob) )	LookupTable fLookupTable; // map ( Index, ( CL, leftside tail prob) )

	protected:	protected:
	ClassDef(SamplingSummaryLookup,1) // A simple class used by Confidence Belt	ClassDef(SamplingSummaryLookup,1) // A simple class used by Confidence Belt
	};	};

	///////////////////////////	///////////////////////////
	class AcceptanceRegion : public TObject{	class AcceptanceRegion : public TObject{
	public:	public:

	AcceptanceRegion() {}	AcceptanceRegion() : fLookupIndex(0), fLowerLimit(0), fUpperLimit(0) { }
	virtual ~AcceptanceRegion() {}	virtual ~AcceptanceRegion() {}

	AcceptanceRegion(Int_t lu, Double_t ll, Double_t ul){	AcceptanceRegion(Int_t lu, Double_t ll, Double_t ul){
	fLookupIndex = lu;	fLookupIndex = lu;
	fLowerLimit = ll;	fLowerLimit = ll;
	fUpperLimit = ul;	fUpperLimit = ul;
	}	}
	Int_t GetLookupIndex(){return fLookupIndex;}	Int_t GetLookupIndex(){return fLookupIndex;}
	Double_t GetLowerLimit(){return fLowerLimit;}	Double_t GetLowerLimit(){return fLowerLimit;}
	Double_t GetUpperLimit(){return fUpperLimit;}	Double_t GetUpperLimit(){return fUpperLimit;}

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

	DataRange.h	DataRange.h

	// @(#)root/mathcore:$Id: DataRange.h 33180 2010-04-25 10:14:07Z moneta $	// @(#)root/mathcore:$Id: DataRange.h 36558 2010-11-09 15:13:13Z moneta $
	// Author: L. Moneta Wed Aug 30 11:05:02 2006	// Author: L. Moneta Wed Aug 30 11:05:02 2006

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for class DataRange	// Header file for class DataRange

	skipping to change at line 69	skipping to change at line 69
	DataRange(double xmin, double xmax, double ymin, double ymax, double zmi n, double zmax);	DataRange(double xmin, double xmax, double ymin, double ymax, double zmi n, double zmax);
	/**	/**
	get range dimension	get range dimension
	*/	*/
	unsigned int NDim() const { return fRanges.size(); }	unsigned int NDim() const { return fRanges.size(); }

	/**	/**
	return range size for coordinate icoord (starts from zero)	return range size for coordinate icoord (starts from zero)
	Size == 0 indicates no range is present [-inf, + inf]	Size == 0 indicates no range is present [-inf, + inf]
	*/	*/

	unsigned int Size(unsigned int icoord) const {	unsigned int Size(unsigned int icoord = 0) const {
	return icoord < fRanges.size() ? fRanges[icoord].size() : 0;	return icoord < fRanges.size() ? fRanges[icoord].size() : 0;
	}	}

	/**	/**
	return true if a range has been set in any of the coordinates	return true if a range has been set in any of the coordinates
	i.e. when it is not [-inf,+inf] for all coordinates	i.e. when it is not [-inf,+inf] for all coordinates
	Avoid in case of multi-dim to loop on all the coordinated and ask the size	Avoid in case of multi-dim to loop on all the coordinated and ask the size
	*/	*/
	bool IsSet() const {	bool IsSet() const {
	for (unsigned int icoord = 0; icoord < fRanges.size(); ++icoord)	for (unsigned int icoord = 0; icoord < fRanges.size(); ++icoord)
	if (fRanges[icoord].size() > 0) return true;	if (fRanges[icoord].size() > 0) return true;
	return false;	return false;
	}	}

	/**	/**
	return the vector of ranges for the coordinate icoord	return the vector of ranges for the coordinate icoord
	*/	*/

	const RangeSet & Ranges(unsigned int icoord) const {	const RangeSet & Ranges(unsigned int icoord = 0) const {
	// return icoord < fRanges.size() ? fRanges[icoord] : RangeSet();	// return icoord < fRanges.size() ? fRanges[icoord] : RangeSet();
	return fRanges.at(icoord);	return fRanges.at(icoord);
	}	}

	/**	/**

	return the first range for the coordinate icoord.	return the i-th range for the coordinate icoord.
	Useful method when only one range is present for the given coordinat e	Useful method when only one range is present for the given coordinat e
	*/	*/

	std::pair<double, double> operator() (unsigned int icoord) const {	std::pair<double, double> operator() (unsigned int icoord = 0,unsigned i
	return Size(icoord) > 0 ? fRanges[icoord].front() : std::make_pair<do	nt irange = 0) const;
	uble,double>(0,0);
	}

	/**	/**
	get the first range for given coordinate. If range does not exist	get the first range for given coordinate. If range does not exist
	return -inf, +inf	return -inf, +inf
	*/	*/
	void GetRange(unsigned int icoord, double & xmin, double & xmax) const {	void GetRange(unsigned int icoord, double & xmin, double & xmax) const {
	if (Size(icoord) == 0) GetInfRange(xmin,xmax);	if (Size(icoord) == 0) GetInfRange(xmin,xmax);
	else {	else {
	xmin = fRanges[icoord].front().first;	xmin = fRanges[icoord].front().first;
	xmax = fRanges[icoord].front().second;	xmax = fRanges[icoord].front().second;

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

	DataSetInfo.h	DataSetInfo.h

	// // @(#)root/tmva $Id: DataSetInfo.h 33928 2010-06-15 16:19:31Z stelzer $	// // @(#)root/tmva $Id: DataSetInfo.h 37097 2010-11-30 12:28:05Z evt $
	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : DataSetInfo *	* Class : DataSetInfo *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Contains all the data information *	* Contains all the data information *

	skipping to change at line 175	skipping to change at line 175
	const TString& hTitle ) const;	const TString& hTitle ) const;

	// options	// options
	void SetSplitOptions(const TString& so) { fSplitOptions = so; fNeedsRebuilding = kTRUE; }	void SetSplitOptions(const TString& so) { fSplitOptions = so; fNeedsRebuilding = kTRUE; }
	const TString& GetSplitOptions() const { return fSplitOptions; }	const TString& GetSplitOptions() const { return fSplitOptions; }

	// root dir	// root dir
	void SetRootDir(TDirectory* d) { fOwnRootDir = d; }	void SetRootDir(TDirectory* d) { fOwnRootDir = d; }
	TDirectory* GetRootDir() const { return fOwnRootDir; }	TDirectory* GetRootDir() const { return fOwnRootDir; }


		void SetMsgType( EMsgType t ) const;

	private:	private:

	TMVA::DataSetManager* fDataSetManager; // DSMTEST	TMVA::DataSetManager* fDataSetManager; // DSMTEST
	void SetDataSetManager( DataSetManager* dsm ) { fDataSetManager = dsm; } // DSMTEST	void SetDataSetManager( DataSetManager* dsm ) { fDataSetManager = dsm; } // DSMTEST
	friend class DataSetManager; // DSMTEST (datasetmanager test)	friend class DataSetManager; // DSMTEST (datasetmanager test)

	DataSetInfo( const DataSetInfo& ) : TObject() {}	DataSetInfo( const DataSetInfo& ) : TObject() {}

	void PrintCorrelationMatrix( TTree* theTree );	void PrintCorrelationMatrix( TTree* theTree );


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

	DecisionTree.h	DecisionTree.h

	// @(#)root/tmva $Id: DecisionTree.h 35739 2010-09-26 11:21:36Z stelzer $	// @(#)root/tmva $Id: DecisionTree.h 37399 2010-12-08 15:22:07Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : DecisionTree *	* Class : DecisionTree *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Implementation of a Decision Tree *	* Implementation of a Decision Tree *

	skipping to change at line 86	skipping to change at line 86

	typedef std::vector<TMVA::Event*> EventList;	typedef std::vector<TMVA::Event*> EventList;

	// the constructur needed for the "reading" of the decision tree from weight files	// the constructur needed for the "reading" of the decision tree from weight files
	DecisionTree( void );	DecisionTree( void );

	// the constructur needed for constructing the decision tree via trai ning with events	// the constructur needed for constructing the decision tree via trai ning with events
	DecisionTree( SeparationBase *sepType, Int_t minSize,	DecisionTree( SeparationBase *sepType, Int_t minSize,
	Int_t nCuts,	Int_t nCuts,
	UInt_t cls =0,	UInt_t cls =0,

	Bool_t randomisedTree=kFALSE, Int_t useNvars=0,	Bool_t randomisedTree=kFALSE, Int_t useNvars=0, Bool_t usePoissonNvars=kFALSE,
	UInt_t nNodesMax=999999, UInt_t nMaxDepth=9999999,	UInt_t nNodesMax=999999, UInt_t nMaxDepth=9999999,
	Int_t iSeed=fgRandomSeed, Float_t purityLimit=0.5,	Int_t iSeed=fgRandomSeed, Float_t purityLimit=0.5,
	Int_t treeID = 0);	Int_t treeID = 0);

	// copy constructor	// copy constructor
	DecisionTree (const DecisionTree &d);	DecisionTree (const DecisionTree &d);

	virtual ~DecisionTree( void );	virtual ~DecisionTree( void );


	virtual Node * CreateNode(UInt_t) const { return new DecisionTreeNode	// Retrieves the address of the root node
	(); }	virtual DecisionTreeNode* GetRoot() const { return dynamic_cast<TMVA:
		:DecisionTreeNode*>(fRoot); }
		virtual DecisionTreeNode * CreateNode(UInt_t) const { return new Deci
		sionTreeNode(); }
	virtual BinaryTree* CreateTree() const { return new DecisionTree(); }	virtual BinaryTree* CreateTree() const { return new DecisionTree(); }

		static DecisionTree* CreateFromXML(void* node, UInt_t tmva_Version_C ode = TMVA_VERSION_CODE);
	virtual const char* ClassName() const { return "DecisionTree"; }	virtual const char* ClassName() const { return "DecisionTree"; }

	// building of a tree by recursivly splitting the nodes	// building of a tree by recursivly splitting the nodes

	UInt_t BuildTree( const EventList & eventSample,	UInt_t BuildTree( const EventList & eventSample,
	DecisionTreeNode *node = NULL);	DecisionTreeNode *node = NULL);
	// determine the way how a node is split (which variable, which cut v alue)	// determine the way how a node is split (which variable, which cut v alue)

	Double_t TrainNode( const EventList & eventSample, DecisionTreeNode *node ) { return TrainNodeFast( eventSample, node ); }	Double_t TrainNode( const EventList & eventSample, DecisionTreeNode *node ) { return TrainNodeFast( eventSample, node ); }
	Double_t TrainNodeFast( const EventList & eventSample, DecisionTreeN ode *node );	Double_t TrainNodeFast( const EventList & eventSample, DecisionTreeN ode *node );
	Double_t TrainNodeFull( const EventList & eventSample, DecisionTreeN ode *node );	Double_t TrainNodeFull( const EventList & eventSample, DecisionTreeN ode *node );

		void GetRandomisedVariables(Bool_t useVariable, UInt_t variableM
		ap, UInt_t & nVars);
		std::vector<Double_t> GetFisherCoefficients(const EventList &eventSa
		mple, UInt_t nFisherVars, UInt_t *mapVarInFisher);

	// fill at tree with a given structure already (just see how many sig na/bkgr	// fill at tree with a given structure already (just see how many sig na/bkgr
	// events end up in each node	// events end up in each node

	void FillTree( EventList & eventSample);	void FillTree( EventList & eventSample);

	// fill the existing the decision tree structure by filling event	// fill the existing the decision tree structure by filling event
	// in from the top node and see where they happen to end up	// in from the top node and see where they happen to end up
	void FillEvent( TMVA::Event & event,	void FillEvent( TMVA::Event & event,
	TMVA::DecisionTreeNode *node );	TMVA::DecisionTreeNode *node );

	skipping to change at line 160	skipping to change at line 165

	// pass a single validation event throught a pruned decision tree	// pass a single validation event throught a pruned decision tree
	void CheckEventWithPrunedTree( const TMVA::Event& ) const;	void CheckEventWithPrunedTree( const TMVA::Event& ) const;

	// calculate the normalization factor for a pruning validation sample	// calculate the normalization factor for a pruning validation sample
	Double_t GetSumWeights( const EventList* validationSample ) const;	Double_t GetSumWeights( const EventList* validationSample ) const;

	void SetNodePurityLimit( Double_t p ) { fNodePurityLimit = p; }	void SetNodePurityLimit( Double_t p ) { fNodePurityLimit = p; }
	Double_t GetNodePurityLimit( ) const { return fNodePurityLimit; }	Double_t GetNodePurityLimit( ) const { return fNodePurityLimit; }


	void DescendTree( DecisionTreeNode *n = NULL );	void DescendTree( Node *n = NULL );
	void SetParentTreeInNodes( DecisionTreeNode *n = NULL );	void SetParentTreeInNodes( Node *n = NULL );

	DecisionTreeNode* GetLeftDaughter( DecisionTreeNode *n );

	DecisionTreeNode* GetRightDaughter( DecisionTreeNode *n );

	// retrieve node from the tree. Its position (up to a maximal tree de pth of 64)	// retrieve node from the tree. Its position (up to a maximal tree de pth of 64)
	// is coded as a sequence of left-right moves starting from the root, coded as	// is coded as a sequence of left-right moves starting from the root, coded as
	// 0-1 bit patterns stored in the "long-integer" together with the de pth	// 0-1 bit patterns stored in the "long-integer" together with the de pth

	DecisionTreeNode* GetNode( ULong_t sequence, UInt_t depth );	Node* GetNode( ULong_t sequence, UInt_t depth );

	UInt_t CleanTree(DecisionTreeNode *node=NULL);	UInt_t CleanTree(DecisionTreeNode *node=NULL);

	void PruneNode(TMVA::DecisionTreeNode *node);	void PruneNode(TMVA::DecisionTreeNode *node);

	// prune a node from the tree without deleting its descendants; allow s one to	// prune a node from the tree without deleting its descendants; allow s one to
	// effectively prune a tree many times without making deep copies	// effectively prune a tree many times without making deep copies
	void PruneNodeInPlace( TMVA::DecisionTreeNode* node );	void PruneNodeInPlace( TMVA::DecisionTreeNode* node );


	UInt_t CountLeafNodes(TMVA::DecisionTreeNode *n = NULL);	UInt_t CountLeafNodes(TMVA::Node *n = NULL);

	void SetTreeID(Int_t treeID){fTreeID = treeID;};	void SetTreeID(Int_t treeID){fTreeID = treeID;};
	Int_t GetTreeID(){return fTreeID;};	Int_t GetTreeID(){return fTreeID;};

	Bool_t DoRegression() const { return fAnalysisType == Types::kRegress ion; }	Bool_t DoRegression() const { return fAnalysisType == Types::kRegress ion; }
	void SetAnalysisType (Types::EAnalysisType t) { fAnalysisType = t;}	void SetAnalysisType (Types::EAnalysisType t) { fAnalysisType = t;}
	Types::EAnalysisType GetAnalysisType ( void ) { return fAnalysisType; }	Types::EAnalysisType GetAnalysisType ( void ) { return fAnalysisType; }

		inline void SetUseFisherCuts(Bool_t t=kTRUE) { fUseFisherCuts = t;}
		inline void SetMinLinCorrForFisher(Double_t min){fMinLinCorrForFisher
		= min;}
		inline void SetUseExclusiveVars(Bool_t t=kTRUE){fUseExclusiveVars = t
		;}

	private:	private:
	// utility functions	// utility functions

	// calculate the Purity out of the number of sig and bkg events colle cted	// calculate the Purity out of the number of sig and bkg events colle cted
	// from individual samples.	// from individual samples.

	// calculates the purity S/(S+B) of a given event sample	// calculates the purity S/(S+B) of a given event sample
	Double_t SamplePurity(EventList eventSample);	Double_t SamplePurity(EventList eventSample);

	UInt_t fNvars; // number of variables used to separate S and B	UInt_t fNvars; // number of variables used to separate S and B
	Int_t fNCuts; // number of grid point in variable cut sc ans	Int_t fNCuts; // number of grid point in variable cut sc ans

		Bool_t fUseFisherCuts; // use multivariate splits using the Fishe
		r criterium
		Double_t fMinLinCorrForFisher; // the minimum linear correlation bet
		ween two variables demanded for use in fisher criterium in node splitting
		Bool_t fUseExclusiveVars; // individual variables already used in
		fisher criterium are not anymore analysed individually for node splitting

	SeparationBase *fSepType; // the separation crition	SeparationBase *fSepType; // the separation crition
	RegressionVariance *fRegType; // the separation crition used in Regr ession	RegressionVariance *fRegType; // the separation crition used in Regr ession

	Double_t fMinSize; // min number of events in node	Double_t fMinSize; // min number of events in node
	Double_t fMinSepGain; // min number of separation gain to perfor m node splitting	Double_t fMinSepGain; // min number of separation gain to perfor m node splitting

	Bool_t fUseSearchTree; // cut scan done with binary trees or simp le event loop.	Bool_t fUseSearchTree; // cut scan done with binary trees or simp le event loop.
	Double_t fPruneStrength; // a parameter to set the "amount" of prun ing..needs to be adjusted	Double_t fPruneStrength; // a parameter to set the "amount" of prun ing..needs to be adjusted

	EPruneMethod fPruneMethod; // method used for prunig	EPruneMethod fPruneMethod; // method used for prunig

	Double_t fNodePurityLimit;// purity limit to decide whether a node i s signal	Double_t fNodePurityLimit;// purity limit to decide whether a node i s signal

	Bool_t fRandomisedTree; // choose at each node splitting a random set of variables	Bool_t fRandomisedTree; // choose at each node splitting a random set of variables
	Int_t fUseNvars; // the number of variables used in randomi sed trees;	Int_t fUseNvars; // the number of variables used in randomi sed trees;

		Bool_t fUsePoissonNvars; // use "fUseNvars" not as fixed number bu t as mean of a possion distr. in each split

	TRandom3 *fMyTrandom; // random number generator for randomised trees	TRandom3 *fMyTrandom; // random number generator for randomised trees

	std::vector< Double_t > fVariableImportance; // the relative importan ce of the different variables	std::vector< Double_t > fVariableImportance; // the relative importan ce of the different variables

	UInt_t fNNodesMax; // max # of nodes	UInt_t fNNodesMax; // max # of nodes
	UInt_t fMaxDepth; // max depth	UInt_t fMaxDepth; // max depth
	UInt_t fClass; // class which is treated as signal when b uilding the tree	UInt_t fClass; // class which is treated as signal when b uilding the tree

	static const Int_t fgDebugLevel = 0; // debug level determining some printout/control plots etc.	static const Int_t fgDebugLevel = 0; // debug level determining some printout/control plots etc.

End of changes. 11 change blocks.
	12 lines changed or deleted	29 lines changed or added

	DistFunc.h	DistFunc.h

	// @(#)root/mathcore:$Id: DistFunc.h 21114 2007-11-29 17:16:45Z moneta $	// @(#)root/mathcore:$Id: DistFunc.h 37160 2010-12-01 21:52:04Z moneta $
	// Authors: L. Moneta, A. Zsenei 08/2005	// Authors: L. Moneta, A. Zsenei 08/2005

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	/**	/**

	skipping to change at line 43	skipping to change at line 43

	//quantiles functions from mathcore	//quantiles functions from mathcore
	#ifndef ROOT_Math_QuantFuncMathCore	#ifndef ROOT_Math_QuantFuncMathCore
	#include "Math/QuantFuncMathCore.h"	#include "Math/QuantFuncMathCore.h"
	#endif	#endif

	// include distributions from MathMore when is there	// include distributions from MathMore when is there
	#ifdef R__HAS_MATHMORE	#ifdef R__HAS_MATHMORE

	// // extra pdf functions from MathMore	// // extra pdf functions from MathMore

	// #ifndef ROOT_Math_PdfFuncMathMore	#ifndef ROOT_Math_PdfFuncMathMore
	// #include "Math/PdfFuncMathMore.h"	#include "Math/PdfFuncMathMore.h"
	// #endif	#endif

	// no -more extra cdf in MathMore	// no -more extra cdf in MathMore
	// #ifndef ROOT_Math_ProbFuncMathMore	// #ifndef ROOT_Math_ProbFuncMathMore
	// #include "Math/ProbFuncMathMore.h"	// #include "Math/ProbFuncMathMore.h"
	// #endif	// #endif

	// inverse (quantiles) are all in mathmore	// inverse (quantiles) are all in mathmore
	#ifndef ROOT_Math_QuantFuncMathMore	#ifndef ROOT_Math_QuantFuncMathMore
	#include "Math/QuantFuncMathMore.h"	#include "Math/QuantFuncMathMore.h"
	#endif	#endif

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

	Error.h		Error.h

	// @(#)root/mathcore:$Id: Error.h 34255 2010-06-30 20:52:37Z moneta $		// @(#)root/mathcore:$Id: Error.h 36766 2010-11-19 10:16:21Z moneta $
	// Authors: L. Moneta		// Authors: L. Moneta

	/**********************************************************************		/**********************************************************************
	* *		* *
	* Copyright (c) 2007 LCG ROOT Math team, CERN/PH-SFT *		* Copyright (c) 2007 LCG ROOT Math team, CERN/PH-SFT *
	* *		* *
	**********************************************************************/		**********************************************************************/

	#ifndef ROOT_Math_Error		#ifndef ROOT_Math_Error
	#define ROOT_Math_Error		#define ROOT_Math_Error

	skipping to change at line 85		skipping to change at line 85
	::Info(sl.c_str(),"%s",str);}		::Info(sl.c_str(),"%s",str);}
	#define MATH_WARN_MSG(loc,str) \		#define MATH_WARN_MSG(loc,str) \
	{std::string sl = "ROOT::Math::" + std::string(loc); \		{std::string sl = "ROOT::Math::" + std::string(loc); \
	::Warning(sl.c_str(),"%s",str);}		::Warning(sl.c_str(),"%s",str);}
	#define MATH_ERROR_MSG(loc,str) \		#define MATH_ERROR_MSG(loc,str) \
	{std::string sl = "ROOT::Math::" + std::string(loc); \		{std::string sl = "ROOT::Math::" + std::string(loc); \
	::Error(sl.c_str(),"%s",str);}		::Error(sl.c_str(),"%s",str);}

	# define MATH_INFO_VAL(loc,x) \		# define MATH_INFO_VAL(loc,x) \
	{std::string sl = "ROOT::Math::" + std::string(loc); \		{std::string sl = "ROOT::Math::" + std::string(loc); \

	std::string str = std::string(#x) + std::string(" = ") + ROOT::Math::Uti l::ToString(x); \		std::string str = std::string(#x) + std::string(" = ") + ::ROOT::Math:: Util::ToString(x); \
	::Info(sl.c_str(),"%s",str.c_str() );}		::Info(sl.c_str(),"%s",str.c_str() );}
	# define MATH_WARN_VAL(loc,x) \		# define MATH_WARN_VAL(loc,x) \
	{std::string sl = "ROOT::Math::" + std::string(loc); \		{std::string sl = "ROOT::Math::" + std::string(loc); \

	std::string str = std::string(#x) + std::string(" = ") + ROOT::Math::Uti l::ToString(x); \		std::string str = std::string(#x) + std::string(" = ") + ::ROOT::Math:: Util::ToString(x); \
	::Warning(sl.c_str(),"%s",str.c_str() );}		::Warning(sl.c_str(),"%s",str.c_str() );}
	# define MATH_ERROR_VAL(loc,x) \		# define MATH_ERROR_VAL(loc,x) \
	{std::string sl = "ROOT::Math::" + std::string(loc); \		{std::string sl = "ROOT::Math::" + std::string(loc); \

	std::string str = std::string(#x) + std::string(" = ") + ROOT::Math::Uti l::ToString(x); \		std::string str = std::string(#x) + std::string(" = ") + ::ROOT::Math:: Util::ToString(x); \
	::Error(sl.c_str(),"%s",str.c_str() );}		::Error(sl.c_str(),"%s",str.c_str() );}

	# define MATH_INFO_MSGVAL(loc,txt,x) \		# define MATH_INFO_MSGVAL(loc,txt,x) \
	{std::string sl = "ROOT::Math::" + std::string(loc); \		{std::string sl = "ROOT::Math::" + std::string(loc); \

	DistFuncMathMore.h	DistFuncMathMore.h

	// @(#)root/mathmore:$Id: DistFuncMathMore.h 21114 2007-11-29 17:16:45Z mon eta $	// @(#)root/mathmore:$Id: DistFuncMathMore.h 37160 2010-12-01 21:52:04Z mon eta $
	// Authors: L. Moneta, A. Zsenei 08/2005	// Authors: L. Moneta, A. Zsenei 08/2005

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *
	* *	* *
	* This library is free software; you can redistribute it and/or *	* This library is free software; you can redistribute it and/or *
	* modify it under the terms of the GNU General Public License *	* modify it under the terms of the GNU General Public License *
	* as published by the Free Software Foundation; either version 2 *	* as published by the Free Software Foundation; either version 2 *
	* of the License, or (at your option) any later version. *	* of the License, or (at your option) any later version. *

	skipping to change at line 28	skipping to change at line 28
	* You should have received a copy of the GNU General Public License *	* You should have received a copy of the GNU General Public License *
	* along with this library (see file COPYING); if not, write *	* along with this library (see file COPYING); if not, write *
	* to the Free Software Foundation, Inc., 59 Temple Place, Suite *	* to the Free Software Foundation, Inc., 59 Temple Place, Suite *
	* 330, Boston, MA 02111-1307 USA, or contact the author. *	* 330, Boston, MA 02111-1307 USA, or contact the author. *
	* *	* *
	**********************************************************************/	**********************************************************************/

	#ifndef ROOT_Math_DistFuncMathMore	#ifndef ROOT_Math_DistFuncMathMore
	#define ROOT_Math_DistFuncMathMore	#define ROOT_Math_DistFuncMathMore


	// #ifndef ROOT_Math_PdfFuncMathMore	#ifndef ROOT_Math_PdfFuncMathMore
	// #include "Math/PdfFuncMathMore.h"	#include "Math/PdfFuncMathMore.h"
	// #endif	#endif

	// #ifndef ROOT_Math_ProbFuncMathMore	// #ifndef ROOT_Math_ProbFuncMathMore
	// #include "Math/ProbFuncMathMore.h"	// #include "Math/ProbFuncMathMore.h"
	// #endif	// #endif

	// quantile functions from mathmore	// quantile functions from mathmore
	#ifndef ROOT_Math_QuantFuncMathMore	#ifndef ROOT_Math_QuantFuncMathMore
	#include "Math/QuantFuncMathMore.h"	#include "Math/QuantFuncMathMore.h"
	#endif	#endif


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

	FastAllocString.h	FastAllocString.h

	skipping to change at line 80	skipping to change at line 80

	// DON'T: these create ambiguities with ::op[char*, int] etc	// DON'T: these create ambiguities with ::op[char*, int] etc
	//char& operator[](int i) { return fBuf[i]; }	//char& operator[](int i) { return fBuf[i]; }
	//char operator[](int i) const { return fBuf[i]; }	//char operator[](int i) const { return fBuf[i]; }
	//char* operator+(int i) { return fBuf + i; }	//char* operator+(int i) { return fBuf + i; }
	//const char* operator+(int i) const { return fBuf + i; }	//const char* operator+(int i) const { return fBuf + i; }

	const char* data() const { return fBuf; }	const char* data() const { return fBuf; }

	int FormatArgList(const char *fmt, va_list args);	int FormatArgList(const char *fmt, va_list args);

		int FormatArgList(size_t offset, const char *fmt, va_list args);
	G__FastAllocString& Format(const char *fmt, ...);	G__FastAllocString& Format(const char *fmt, ...);

		G__FastAllocString& Format(size_t offset, const char *fmt, ...);

	size_t Capacity() const { return fCapacity; }	size_t Capacity() const { return fCapacity; }

	G__FastAllocString& operator=(const G__FastAllocString& s) {	G__FastAllocString& operator=(const G__FastAllocString& s) {
	// Copy s into *this.	// Copy s into *this.
	// Cannot rely on operator=(const char*) overload - compiler-generate d one wins resolution!	// Cannot rely on operator=(const char*) overload - compiler-generate d one wins resolution!
	return operator=(s.data());	return operator=(s.data());
	}	}
	G__FastAllocString& operator=(const char*);	G__FastAllocString& operator=(const char*);
	G__FastAllocString& operator+=(const char*);	G__FastAllocString& operator+=(const char*);

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

	FitResult.h	FitResult.h

	// @(#)root/mathcore:$Id: FitResult.h 34753 2010-08-10 10:02:27Z moneta $	// @(#)root/mathcore:$Id: FitResult.h 37438 2010-12-09 14:14:30Z moneta $
	// Author: L. Moneta Wed Aug 30 11:05:34 2006	// Author: L. Moneta Wed Aug 30 11:05:34 2006

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for class FitResult	// Header file for class FitResult

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

	/**	/**
	get confidence intervals for an array of n points x.	get confidence intervals for an array of n points x.
	stride1 indicates the stride in the coordinate space while stride2 th e stride in dimension space.	stride1 indicates the stride in the coordinate space while stride2 th e stride in dimension space.
	For 1-dim points : stride1=1, stride2=1	For 1-dim points : stride1=1, stride2=1
	for multi-dim points arranged as (x0,x1,...,xN,y0,....yN) st ride1=1 stride2=n	for multi-dim points arranged as (x0,x1,...,xN,y0,....yN) st ride1=1 stride2=n
	for multi-dim points arraged as (x0,y0,..,x1,y1,...,xN,yN,..) st ride1=ndim, stride2=1	for multi-dim points arraged as (x0,y0,..,x1,y1,...,xN,yN,..) st ride1=ndim, stride2=1

	the confidence interval are returned in the array ci	the confidence interval are returned in the array ci
	cl is the desired confidedence interval value	cl is the desired confidedence interval value

		norm is a flag to control if the intervals need to be normalized to t
		he chi2/ndf value
		By default the intervals are corrected using the chi2/ndf value of th
		e fit if a chi2 fit is performed
	*/	*/

	void GetConfidenceIntervals(unsigned int n, unsigned int stride1, unsign ed int stride2, const double * x, double * ci, double cl=0.95 ) const;	void GetConfidenceIntervals(unsigned int n, unsigned int stride1, unsign ed int stride2, const double * x, double * ci, double cl=0.95, bool norm = true ) const;

	/**	/**
	evaluate confidence interval for the point specified in the passed da ta sets	evaluate confidence interval for the point specified in the passed da ta sets
	the confidence interval are returned in the array ci	the confidence interval are returned in the array ci
	cl is the desired confidence interval value	cl is the desired confidence interval value
	*/	*/

	void GetConfidenceIntervals(const BinData & data, double * ci, double cl =0.95 ) const;	void GetConfidenceIntervals(const BinData & data, double * ci, double cl =0.95, bool norm = true ) const;

	/// get index for parameter name (return -1 if not found)	/// get index for parameter name (return -1 if not found)
	int Index(const std::string & name) const;	int Index(const std::string & name) const;

	///normalize errors using chi2/ndf for chi2 fits	///normalize errors using chi2/ndf for chi2 fits
	void NormalizeErrors();	void NormalizeErrors();

	/// flag to chek if errors are normalized	/// flag to chek if errors are normalized
	bool NormalizedErrors() { return fNormalized; }	bool NormalizedErrors() { return fNormalized; }


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

	GSLMinimizer.h	GSLMinimizer.h

	// @(#)root/mathmore:$Id: GSLMinimizer.h 31604 2009-12-07 19:04:33Z moneta $	// @(#)root/mathmore:$Id: GSLMinimizer.h 37448 2010-12-09 20:20:56Z moneta $
	// Author: L. Moneta Wed Oct 18 11:48:00 2006	// Author: L. Moneta Wed Oct 18 11:48:00 2006

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* This library is free software; you can redistribute it and/or *	* This library is free software; you can redistribute it and/or *
	* modify it under the terms of the GNU General Public License *	* modify it under the terms of the GNU General Public License *
	* as published by the Free Software Foundation; either version 2 *	* as published by the Free Software Foundation; either version 2 *
	* of the License, or (at your option) any later version. *	* of the License, or (at your option) any later version. *

	skipping to change at line 161	skipping to change at line 161
	/// return expected distance reached from the minimum	/// return expected distance reached from the minimum
	virtual double Edm() const { return 0; } // not impl. }	virtual double Edm() const { return 0; } // not impl. }

	/// return pointer to X values at the minimum	/// return pointer to X values at the minimum
	virtual const double * X() const { return &fValues.front(); }	virtual const double * X() const { return &fValues.front(); }

	/// return pointer to gradient values at the minimum	/// return pointer to gradient values at the minimum
	virtual const double * MinGradient() const;	virtual const double * MinGradient() const;

	/// number of function calls to reach the minimum	/// number of function calls to reach the minimum

	virtual unsigned int NCalls() const { return 0; } // not yet ipl.	virtual unsigned int NCalls() const;

	/// this is <= Function().NDim() which is the total	/// this is <= Function().NDim() which is the total
	/// number of variables (free+ constrained ones)	/// number of variables (free+ constrained ones)
	virtual unsigned int NDim() const { return fValues.size(); }	virtual unsigned int NDim() const { return fValues.size(); }

	/// number of free variables (real dimension of the problem)	/// number of free variables (real dimension of the problem)
	/// this is <= Function().NDim() which is the total number of free param eters	/// this is <= Function().NDim() which is the total number of free param eters
	virtual unsigned int NFree() const { return fObjFunc->NDim(); }	virtual unsigned int NFree() const { return fObjFunc->NDim(); }

	/// minimizer provides error and error matrix	/// minimizer provides error and error matrix

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

	GSLNLSMinimizer.h	GSLNLSMinimizer.h

	// @(#)root/mathmore:$Id: GSLNLSMinimizer.h 33180 2010-04-25 10:14:07Z mone ta $	// @(#)root/mathmore:$Id: GSLNLSMinimizer.h 37427 2010-12-09 08:57:45Z mone ta $
	// Author: L. Moneta Wed Dec 20 17:16:32 2006	// Author: L. Moneta Wed Dec 20 17:16:32 2006

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* This library is free software; you can redistribute it and/or *	* This library is free software; you can redistribute it and/or *
	* modify it under the terms of the GNU General Public License *	* modify it under the terms of the GNU General Public License *
	* as published by the Free Software Foundation; either version 2 *	* as published by the Free Software Foundation; either version 2 *
	* of the License, or (at your option) any later version. *	* of the License, or (at your option) any later version. *

	skipping to change at line 224	skipping to change at line 224
	/// return expected distance reached from the minimum	/// return expected distance reached from the minimum
	virtual double Edm() const { return fEdm; } // not impl. }	virtual double Edm() const { return fEdm; } // not impl. }

	/// return pointer to X values at the minimum	/// return pointer to X values at the minimum
	virtual const double * X() const { return &fValues.front(); }	virtual const double * X() const { return &fValues.front(); }

	/// return pointer to gradient values at the minimum	/// return pointer to gradient values at the minimum
	virtual const double * MinGradient() const;	virtual const double * MinGradient() const;

	/// number of function calls to reach the minimum	/// number of function calls to reach the minimum

	virtual unsigned int NCalls() const { return 0; } // not yet ipl.	virtual unsigned int NCalls() const { return (fObjFunc) ? fObjFunc->NCal ls() : 0; }

	/// this is <= Function().NDim() which is the total	/// this is <= Function().NDim() which is the total
	/// number of variables (free+ constrained ones)	/// number of variables (free+ constrained ones)
	virtual unsigned int NDim() const { return fDim; }	virtual unsigned int NDim() const { return fDim; }

	/// number of free variables (real dimension of the problem)	/// number of free variables (real dimension of the problem)
	/// this is <= Function().NDim() which is the total	/// this is <= Function().NDim() which is the total
	virtual unsigned int NFree() const { return fNFree; }	virtual unsigned int NFree() const { return fNFree; }

	/// minimizer provides error and error matrix	/// minimizer provides error and error matrix

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

	GaussIntegrator.h	GaussIntegrator.h

	// @(#)root/mathcore:$Id: GaussIntegrator.h 35386 2010-09-17 15:39:51Z mone ta $	// @(#)root/mathcore:$Id: GaussIntegrator.h 36764 2010-11-19 10:02:00Z mone ta $
	// Authors: David Gonzalez Maline 01/2008	// Authors: David Gonzalez Maline 01/2008

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 , LCG ROOT MathLib Team *	* Copyright (c) 2006 , LCG ROOT MathLib Team *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for GaussIntegrator	// Header file for GaussIntegrator

	skipping to change at line 199	skipping to change at line 199
	\@param f Function to be used in the calculations.	\@param f Function to be used in the calculations.
	*/	*/
	void SetFunction (const IGenFunction &);	void SetFunction (const IGenFunction &);

	/** This method is not implemented. */	/** This method is not implemented. */
	double Integral (const std::vector< double > &pts);	double Integral (const std::vector< double > &pts);

	/** This method is not implemented. */	/** This method is not implemented. */
	double IntegralCauchy (double a, double b, double c);	double IntegralCauchy (double a, double b, double c);


		/// get the option used for the integration
		virtual ROOT::Math::IntegratorOneDimOptions Options() const;

		// set the options
		virtual void SetOptions(const ROOT::Math::IntegratorOneDimOptions & opt)
		;

	private:	private:

	/**	/**
	Integration surrugate method. Return integral of passed function in interval [a,b]	Integration surrugate method. Return integral of passed function in interval [a,b]
	Derived class (like GaussLegendreIntegrator) can re-implement this m ethod to modify to use	Derived class (like GaussLegendreIntegrator) can re-implement this m ethod to modify to use
	an improved algorithm	an improved algorithm
	*/	*/
	virtual double DoIntegral (double a, double b, const IGenFunction* func) ;	virtual double DoIntegral (double a, double b, const IGenFunction* func) ;

	protected:	protected:

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

	Hoption.h	Hoption.h

	/* @(#)root/histpainter:$Id: Hoption.h 21648 2008-01-11 16:16:26Z couet $ * /	/* @(#)root/histpainter:$Id: Hoption.h 36077 2010-10-05 09:16:06Z brun $ */

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, 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_Hoption	#ifndef ROOT_Hoption

	skipping to change at line 36	skipping to change at line 36
	int Bar; // "B" A Bar chart is drawn at each point.	int Bar; // "B" A Bar chart is drawn at each point.
	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 Plus; // "+", "-", "+-" Bin contents are added and/or substr acted
	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 of fit).	int Func; // "FUNC" Draw only the function (for example in case 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 =11, LEGO2,Lego=12).	int Lego; // "LEGO" Draw as a Lego plot(LEGO,Lego=1, LEGO1,Lego1 =11, LEGO2,Lego=12).
	int Scat; // "SCAT" Draw 2D plot a Scatter plot.	int Scat; // "SCAT" Draw 2D plot a Scatter plot.

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

	HypoTestInverterResult.h	HypoTestInverterResult.h

	// @(#)root/roostats:$Id: HypoTestInverterResult.h 31798 2009-12-10 14:57:1 5Z moneta $	// @(#)root/roostats:$Id: HypoTestInverterResult.h 36230 2010-10-09 20:21:0 2Z wouter $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, 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 ROOSTATS_HypoTestInverterResult	#ifndef ROOSTATS_HypoTestInverterResult

	skipping to change at line 79	skipping to change at line 79
	//function evaluates only a rought error on the lower limit. Be careful when using this estimation	//function evaluates only a rought error on the lower limit. Be careful when using this estimation
	Double_t LowerLimitEstimatedError();	Double_t LowerLimitEstimatedError();

	// Estimate of lower limit error	// Estimate of lower limit error
	//function evaluates only a rought error on the lower limit. Be careful when using this estimation	//function evaluates only a rought error on the lower limit. Be careful when using this estimation
	Double_t UpperLimitEstimatedError();	Double_t UpperLimitEstimatedError();

	private:	private:

	// merge with the content of another HypoTestInverterResult object	// merge with the content of another HypoTestInverterResult object

	bool Add( HypoTestInverterResult otherResult );	bool Add( const HypoTestInverterResult& otherResult );

	double CalculateEstimatedError(double target);	double CalculateEstimatedError(double target);
	int FindClosestPointIndex(double target);	int FindClosestPointIndex(double target);
	double FindInterpolatedLimit(double target);	double FindInterpolatedLimit(double target);

	protected:	protected:

	bool fUseCLs;	bool fUseCLs;
	bool fInterpolateLowerLimit;	bool fInterpolateLowerLimit;
	bool fInterpolateUpperLimit;	bool fInterpolateUpperLimit;

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

	HypoTestResult.h	HypoTestResult.h

	// @(#)root/roostats:$Id: HypoTestResult.h 34109 2010-06-24 15:00:16Z monet a $	// @(#)root/roostats:$Id: HypoTestResult.h 36602 2010-11-11 16:52:13Z monet a $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke, S ven Kreiss	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke, S ven Kreiss
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, 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 ROOSTATS_HypoTestResult	#ifndef ROOSTATS_HypoTestResult

	skipping to change at line 80	skipping to change at line 80
	SamplingDistribution* GetNullDistribution(void) const { return fNullD istr; }	SamplingDistribution* GetNullDistribution(void) const { return fNullD istr; }
	SamplingDistribution* GetAltDistribution(void) const { return fAltDis tr; }	SamplingDistribution* GetAltDistribution(void) const { return fAltDis tr; }
	Double_t GetTestStatisticData(void) const { return fTestStatisticData ; }	Double_t GetTestStatisticData(void) const { return fTestStatisticData ; }
	Bool_t HasTestStatisticData(void) const;	Bool_t HasTestStatisticData(void) const;

	void SetAltDistribution(SamplingDistribution *alt);	void SetAltDistribution(SamplingDistribution *alt);
	void SetNullDistribution(SamplingDistribution *null);	void SetNullDistribution(SamplingDistribution *null);
	void SetTestStatisticData(const Double_t tsd);	void SetTestStatisticData(const Double_t tsd);

	void SetPValueIsRightTail(Bool_t pr);	void SetPValueIsRightTail(Bool_t pr);

	Bool_t GetPValueIsRightTail(void) { return fPValueIsRightTail; }	Bool_t GetPValueIsRightTail(void) const { return fPValueIsRightTail; }

	/// The error on the "confidence level" of the null hypothesis	/// The error on the "confidence level" of the null hypothesis
	Double_t CLbError() const;	Double_t CLbError() const;

	/// The error on the "confidence level" of the alternative hypothesis	/// The error on the "confidence level" of the alternative hypothesis
	Double_t CLsplusbError() const;	Double_t CLsplusbError() const;

	/// The error on the ratio CLs+b/CLb	/// The error on the ratio CLs+b/CLb
	Double_t CLsError() const;	Double_t CLsError() const;


	void Print(const Option_t* ) const {	Double_t NullPValueError() const;

		void Print(const Option_t* = "") const {
	// Print out some information about the results	// Print out some information about the results

	cout << endl << "Results " << GetName() << ": " << endl;	cout << endl << "Results " << GetName() << ": " << endl;

	cout << " - Null p-value = " << NullPValue() << endl;	if(HasTestStatisticData() && fNullDistr) {
	cout << " - Significance = " << Significance() << " sigma" << endl;	cout << " - Null p-value = " << NullPValue() << " +/- " << Null
		PValueError() << endl;
		cout << " - Significance = " << Significance() << " sigma" << e
		ndl;
		}
	if(fAltDistr)	if(fAltDistr)
	cout << " - Number of S+B toys: " << fAltDistr->GetSize() << st d::endl;	cout << " - Number of S+B toys: " << fAltDistr->GetSize() << st d::endl;
	if(fNullDistr)	if(fNullDistr)
	cout << " - Number of B toys: " << fNullDistr->GetSize() << std ::endl;	cout << " - Number of B toys: " << fNullDistr->GetSize() << std ::endl;
	if(HasTestStatisticData())	if(HasTestStatisticData())
	cout << " - Test statistic evaluated on data: " << fTestStatist icData << std::endl;	cout << " - Test statistic evaluated on data: " << fTestStatist icData << std::endl;
	if(HasTestStatisticData() && fNullDistr)	if(HasTestStatisticData() && fNullDistr)
	cout << " - CL_b: " << CLb() << " +/- " << CLbError() << std::e ndl;	cout << " - CL_b: " << CLb() << " +/- " << CLbError() << std::e ndl;
	if(HasTestStatisticData() && fAltDistr)	if(HasTestStatisticData() && fAltDistr)
	cout << " - CL_s+b: " << CLsplusb() << " +/- " << CLsplusbError () << std::endl;	cout << " - CL_s+b: " << CLsplusb() << " +/- " << CLsplusbError () << std::endl;

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

	LogLikelihoodFCN.h	LogLikelihoodFCN.h

	// @(#)root/mathcore:$Id: LogLikelihoodFCN.h 32508 2010-03-09 10:51:11Z rdm $	// @(#)root/mathcore:$Id: LogLikelihoodFCN.h 37232 2010-12-03 18:09:43Z mon eta $
	// Author: L. Moneta Fri Aug 17 14:29:24 2007	// Author: L. Moneta Fri Aug 17 14:29:24 2007

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2007 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2007 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for class LogLikelihoodFCN	// Header file for class LogLikelihoodFCN

	skipping to change at line 102	skipping to change at line 102
	/// clone the function (need to return Base for Windows)	/// clone the function (need to return Base for Windows)
	virtual BaseFunction * Clone() const { return new LogLikelihoodFCN(fDat a,fFunc); }	virtual BaseFunction * Clone() const { return new LogLikelihoodFCN(fDat a,fFunc); }

	//using BaseObjFunction::operator();	//using BaseObjFunction::operator();

	// effective points used in the fit	// effective points used in the fit
	virtual unsigned int NFitPoints() const { return fNEffPoints; }	virtual unsigned int NFitPoints() const { return fNEffPoints; }

	/// i-th likelihood contribution and its gradient	/// i-th likelihood contribution and its gradient
	virtual double DataElement(const double * x, unsigned int i, double * g) const {	virtual double DataElement(const double * x, unsigned int i, double * g) const {

		if (i==0) this->UpdateNCalls();
	return FitUtil::EvaluatePdf(fFunc, fData, x, i, g);	return FitUtil::EvaluatePdf(fFunc, fData, x, i, g);
	}	}

	// need to be virtual to be instantited	// need to be virtual to be instantited
	virtual void Gradient(const double x, double g) const {	virtual void Gradient(const double x, double g) const {
	// evaluate the chi2 gradient	// evaluate the chi2 gradient
	FitUtil::EvaluateLogLGradient(fFunc, fData, x, g, fNEffPoints);	FitUtil::EvaluateLogLGradient(fFunc, fData, x, g, fNEffPoints);
	}	}

	/// get type of fit method function	/// get type of fit method function

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

	MethodANNBase.h	MethodANNBase.h

	// @(#)root/tmva $Id: MethodANNBase.h 33928 2010-06-15 16:19:31Z stelzer $	// @(#)root/tmva $Id: MethodANNBase.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Andreas Hoecker, Peter Speckmayer, Matt Jachowski	// Author: Andreas Hoecker, Peter Speckmayer, Matt Jachowski

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodANNBase *	* Class : MethodANNBase *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Artificial neural network base class for the discrimination of sign al *	* Artificial neural network base class for the discrimination of sign al *

	skipping to change at line 123	skipping to change at line 123
	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	// write weights to file	// write weights to file
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;
	void ReadWeightsFromXML( void* wghtnode );	void ReadWeightsFromXML( void* wghtnode );

	// read weights from file	// read weights from file
	virtual void ReadWeightsFromStream( istream& istr );	virtual void ReadWeightsFromStream( istream& istr );

	// calculate the MVA value	// calculate the MVA value

	virtual Double_t GetMvaValue( Double_t* err = 0 );	virtual Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0 );

	virtual const std::vector<Float_t> &GetRegressionValues();	virtual const std::vector<Float_t> &GetRegressionValues();

	virtual const std::vector<Float_t> &GetMulticlassValues();	virtual const std::vector<Float_t> &GetMulticlassValues();

	// write method specific histos to target file	// write method specific histos to target file
	virtual void WriteMonitoringHistosToFile() const;	virtual void WriteMonitoringHistosToFile() const;

	// ranking of input variables	// ranking of input variables
	const Ranking* CreateRanking();	const Ranking* CreateRanking();

	skipping to change at line 191	skipping to change at line 191
	// monitoring histograms (not available for regression)	// monitoring histograms (not available for regression)
	void CreateWeightMonitoringHists( const TString& bulkname, std::vecto r<TH1> hv = 0 ) const;	void CreateWeightMonitoringHists( const TString& bulkname, std::vecto r<TH1> hv = 0 ) const;
	std::vector<TH1*> fEpochMonHistS; // epoch monitoring hitograms for s ignal	std::vector<TH1*> fEpochMonHistS; // epoch monitoring hitograms for s ignal
	std::vector<TH1*> fEpochMonHistB; // epoch monitoring hitograms for b ackground	std::vector<TH1*> fEpochMonHistB; // epoch monitoring hitograms for b ackground
	std::vector<TH1*> fEpochMonHistW; // epoch monitoring hitograms for w eights	std::vector<TH1*> fEpochMonHistW; // epoch monitoring hitograms for w eights

	// general	// general
	TMatrixD fInvHessian; // zjh	TMatrixD fInvHessian; // zjh
	bool fUseRegulator; // zjh	bool fUseRegulator; // zjh


		protected:
		Int_t fRandomSeed; // random seed for initial
		synapse weights

	private:	private:

	// helper functions for building network	// helper functions for building network
	void BuildLayers(std::vector<Int_t>* layout, Bool_t from_file = false );	void BuildLayers(std::vector<Int_t>* layout, Bool_t from_file = false );
	void BuildLayer(Int_t numNeurons, TObjArray* curLayer, TObjArray* pre vLayer,	void BuildLayer(Int_t numNeurons, TObjArray* curLayer, TObjArray* pre vLayer,
	Int_t layerIndex, Int_t numLayers, Bool_t from_file = false);	Int_t layerIndex, Int_t numLayers, Bool_t from_file = false);
	void AddPreLinks(TNeuron* neuron, TObjArray* prevLayer);	void AddPreLinks(TNeuron* neuron, TObjArray* prevLayer);

	// helper functions for weight initialization	// helper functions for weight initialization
	void InitWeights();	void InitWeights();

	skipping to change at line 218	skipping to change at line 221
	void PrintLayer(TObjArray* layer) const;	void PrintLayer(TObjArray* layer) const;
	void PrintNeuron(TNeuron* neuron) const;	void PrintNeuron(TNeuron* neuron) const;

	// private variables	// private variables
	Int_t fNcycles; // number of epochs to trai n	Int_t fNcycles; // number of epochs to trai n
	TString fNeuronType; // name of neuron activatio n function class	TString fNeuronType; // name of neuron activatio n function class
	TString fNeuronInputType; // name of neuron input cal culator class	TString fNeuronInputType; // name of neuron input cal culator class
	TObjArray* fInputLayer; // cache this for fast acce ss	TObjArray* fInputLayer; // cache this for fast acce ss
	std::vector<TNeuron*> fOutputNeurons; // cache this for fast acce ss	std::vector<TNeuron*> fOutputNeurons; // cache this for fast acce ss
	TString fLayerSpec; // layout specification opt ion	TString fLayerSpec; // layout specification opt ion

	Int_t fRandomSeed; // random seed for initial synapse weights

	// some static flags	// some static flags
	static const Bool_t fgDEBUG = kTRUE; // debug flag	static const Bool_t fgDEBUG = kTRUE; // debug flag

	ClassDef(MethodANNBase,0) // Base class for TMVA ANNs	ClassDef(MethodANNBase,0) // Base class for TMVA ANNs
	};	};

	} // namespace TMVA	} // namespace TMVA

	#endif	#endif

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

	MethodCFMlpANN.h	MethodCFMlpANN.h

	// @(#)root/tmva $Id: MethodCFMlpANN.h 33928 2010-06-15 16:19:31Z stelzer $	// @(#)root/tmva $Id: MethodCFMlpANN.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodCFMlpANN *	* Class : MethodCFMlpANN *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Interface for Clermond-Ferrand artificial neural network. *	* Interface for Clermond-Ferrand artificial neural network. *

	skipping to change at line 132	skipping to change at line 132

	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	// write weights to file	// write weights to file
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( istream& istr );	void ReadWeightsFromStream( istream& istr );
	void ReadWeightsFromXML( void* wghtnode );	void ReadWeightsFromXML( void* wghtnode );
	// calculate the MVA value	// calculate the MVA value

	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0 );

	// data accessors for external functions	// data accessors for external functions
	Double_t GetData ( Int_t isel, Int_t ivar ) const { return (*fData)(i sel, ivar); }	Double_t GetData ( Int_t isel, Int_t ivar ) const { return (*fData)(i sel, ivar); }
	Int_t GetClass( Int_t ivar ) const { return (*fClass)[ ivar]; }	Int_t GetClass( Int_t ivar ) const { return (*fClass)[ ivar]; }

	// static pointer to this object (required for external functions	// static pointer to this object (required for external functions
	static MethodCFMlpANN* This( void );	static MethodCFMlpANN* This( void );

	// ranking of input variables	// ranking of input variables
	const Ranking* CreateRanking() { return 0; }	const Ranking* CreateRanking() { return 0; }

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

	MethodCuts.h	MethodCuts.h

	// @(#)root/tmva $Id: MethodCuts.h 31458 2009-11-30 13:58:20Z stelzer $	// @(#)root/tmva $Id: MethodCuts.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Andreas Hoecker, Matt Jachowski, Peter Speckmayer, Helge Voss, K ai Voss	// Author: Andreas Hoecker, Matt Jachowski, Peter Speckmayer, Helge Voss, K ai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodCuts *	* Class : MethodCuts *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Multivariate optimisation of signal efficiency for given background *	* Multivariate optimisation of signal efficiency for given background *

	skipping to change at line 107	skipping to change at line 107
	void Train( void );	void Train( void );

	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	void AddWeightsXMLTo ( void* parent ) const;	void AddWeightsXMLTo ( void* parent ) const;

	void ReadWeightsFromStream( std::istream & i );	void ReadWeightsFromStream( std::istream & i );
	void ReadWeightsFromXML ( void* wghtnode );	void ReadWeightsFromXML ( void* wghtnode );

	// calculate the MVA value (for CUTs this is just a dummy)	// calculate the MVA value (for CUTs this is just a dummy)

	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0 );

	// write method specific histos to target file	// write method specific histos to target file
	void WriteMonitoringHistosToFile( void ) const;	void WriteMonitoringHistosToFile( void ) const;

	// test the method	// test the method
	void TestClassification();	void TestClassification();

	// also overwrite --> not computed for cuts	// also overwrite --> not computed for cuts
	Double_t GetSeparation ( TH1, TH1 ) const { return -1; }	Double_t GetSeparation ( TH1, TH1 ) const { return -1; }
	Double_t GetSeparation ( PDF* = 0, PDF* = 0 ) const { return -1; }	Double_t GetSeparation ( PDF* = 0, PDF* = 0 ) const { return -1; }

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

	MethodDT.h	MethodDT.h

	// @(#)root/tmva $Id: MethodDT.h 31458 2009-11-30 13:58:20Z stelzer $	// @(#)root/tmva $Id: MethodDT.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodDT (Boosted Decision Trees) *	* Class : MethodDT (Boosted Decision Trees) *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Analysis of Boosted Decision Trees *	* Analysis of Boosted Decision Trees *

	skipping to change at line 86	skipping to change at line 86

	void Train( void );	void Train( void );

	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	// write weights to file	// write weights to file
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( istream& istr );	void ReadWeightsFromStream( istream& istr );

	void ReadWeightsFromXML ( void* /wghtnode/ ) {}	void ReadWeightsFromXML ( void* wghtnode );

	// calculate the MVA value	// calculate the MVA value

	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0 );

	// the option handling methods	// the option handling methods
	void DeclareOptions();	void DeclareOptions();
	void ProcessOptions();	void ProcessOptions();

	void GetHelpMessage() const;	void GetHelpMessage() const;

	// ranking of input variables	// ranking of input variables
	const Ranking* CreateRanking();	const Ranking* CreateRanking();


	skipping to change at line 125	skipping to change at line 125

	DecisionTree* fTree; // the decision tre e	DecisionTree* fTree; // the decision tre e
	//options for the decision Tree	//options for the decision Tree
	SeparationBase *fSepType; // the separation u sed in node splitting	SeparationBase *fSepType; // the separation u sed in node splitting
	TString fSepTypeS; // the separation ( option string) used in node splitting	TString fSepTypeS; // the separation ( option string) used in node splitting
	Int_t fNodeMinEvents; // min number of ev ents in node	Int_t fNodeMinEvents; // min number of ev ents in node

	Int_t fNCuts; // grid used in cut applied in node splitting	Int_t fNCuts; // grid used in cut applied in node splitting
	Bool_t fUseYesNoLeaf; // use sig or bkg c lassification in leave nodes or sig/bkg	Bool_t fUseYesNoLeaf; // use sig or bkg c lassification in leave nodes or sig/bkg
	Double_t fNodePurityLimit; // purity limit for sig/bkg nodes	Double_t fNodePurityLimit; // purity limit for sig/bkg nodes

		UInt_t fNNodesMax; // max # of nodes
		UInt_t fMaxDepth; // max depth

	Double_t fErrorFraction; // ntuple var: mis classification error fraction	Double_t fErrorFraction; // ntuple var: mis classification error fraction
	Double_t fPruneStrength; // a parameter to set the "amount" of pruning..needs to be adjusted	Double_t fPruneStrength; // a parameter to set the "amount" of pruning..needs to be adjusted
	DecisionTree::EPruneMethod fPruneMethod; // method used for prunig	DecisionTree::EPruneMethod fPruneMethod; // method used for prunig
	TString fPruneMethodS; // prune method op tion String	TString fPruneMethodS; // prune method op tion String
	Bool_t fAutomatic; // use user given prune strength or automatically determined one using a validation sample	Bool_t fAutomatic; // use user given prune strength or automatically determined one using a validation sample
	Bool_t fRandomisedTrees; // choose a random subset of possible cut variables at each node during training	Bool_t fRandomisedTrees; // choose a random subset of possible cut variables at each node during training
	Int_t fUseNvars; // the number of v ariables used in the randomised tree splitting	Int_t fUseNvars; // the number of v ariables used in the randomised tree splitting
	Bool_t fPruneBeforeBoost; //whether to prun e right after the training (before the boosting)	Bool_t fPruneBeforeBoost; //whether to prun e right after the training (before the boosting)


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

	PDEFoamCell.h	PDEFoamCell.h

	skipping to change at line 105	skipping to change at line 105
	Int_t GetStat() const { return fStatus;} // Get Status	Int_t GetStat() const { return fStatus;} // Get Status
	void SetStat(Int_t Stat){ fStatus=Stat;} // Set Status	void SetStat(Int_t Stat){ fStatus=Stat;} // Set Status
	PDEFoamCell* GetPare() const { return (PDEFoamCell*) fParent.GetObjec t(); } // Get Pointer to parent cell	PDEFoamCell* GetPare() const { return (PDEFoamCell*) fParent.GetObjec t(); } // Get Pointer to parent cell
	PDEFoamCell* GetDau0() const { return (PDEFoamCell*) fDaught0.GetObje ct(); } // Get Pointer to 1-st daughter vertex	PDEFoamCell* GetDau0() const { return (PDEFoamCell*) fDaught0.GetObje ct(); } // Get Pointer to 1-st daughter vertex
	PDEFoamCell* GetDau1() const { return (PDEFoamCell*) fDaught1.GetObje ct(); } // Get Pointer to 2-nd daughter vertex	PDEFoamCell* GetDau1() const { return (PDEFoamCell*) fDaught1.GetObje ct(); } // Get Pointer to 2-nd daughter vertex
	void SetDau0(PDEFoamCell* Daug){ fDaught0 = Daug;} // Set point er to 1-st daughter	void SetDau0(PDEFoamCell* Daug){ fDaught0 = Daug;} // Set point er to 1-st daughter
	void SetDau1(PDEFoamCell* Daug){ fDaught1 = Daug;} // Set point er to 2-nd daughter	void SetDau1(PDEFoamCell* Daug){ fDaught1 = Daug;} // Set point er to 2-nd daughter
	void SetPare(PDEFoamCell* Pare){ fParent = Pare;} // Set point er to parent	void SetPare(PDEFoamCell* Pare){ fParent = Pare;} // Set point er to parent
	void SetSerial(Int_t Serial){ fSerial=Serial;} // Set serial number	void SetSerial(Int_t Serial){ fSerial=Serial;} // Set serial number
	Int_t GetSerial() const { return fSerial;} // Get serial number	Int_t GetSerial() const { return fSerial;} // Get serial number

		UInt_t GetDepth(); // Get depth i n binary tree
	//--- other ---	//--- other ---
	void Print(Option_t *option) const ; // Prints cell content	void Print(Option_t *option) const ; // Prints cell content
	//--- getter and setter for user variable ---	//--- getter and setter for user variable ---
	void SetElement(TObject* fobj){ fElement = fobj; } // Set user va riable	void SetElement(TObject* fobj){ fElement = fobj; } // Set user va riable
	TObject* GetElement() const { return fElement; } // Get pointer to user varibale	TObject* GetElement() const { return fElement; } // Get pointer to user varibale
	///////////////////////////////////////////////////////////////////// ///////	///////////////////////////////////////////////////////////////////// ///////
	ClassDef(PDEFoamCell,1) //Single cell of FOAM	ClassDef(PDEFoamCell,1) //Single cell of FOAM
	}; // end of PDEFoamCell	}; // end of PDEFoamCell
	} // namespace TMVA	} // namespace TMVA


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

	PoissonLikelihoodFCN.h	PoissonLikelihoodFCN.h

	// @(#)root/mathcore:$Id: PoissonLikelihoodFCN.h 32508 2010-03-09 10:51:11Z rdm $	// @(#)root/mathcore:$Id: PoissonLikelihoodFCN.h 37232 2010-12-03 18:09:43Z moneta $
	// Author: L. Moneta Fri Aug 17 14:29:24 2007	// Author: L. Moneta Fri Aug 17 14:29:24 2007

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2007 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2007 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for class PoissonLikelihoodFCN	// Header file for class PoissonLikelihoodFCN

	skipping to change at line 100	skipping to change at line 100
	public:	public:

	/// clone the function (need to return Base for Windows)	/// clone the function (need to return Base for Windows)
	virtual BaseFunction * Clone() const { return new PoissonLikelihoodFCN( fData,fFunc); }	virtual BaseFunction * Clone() const { return new PoissonLikelihoodFCN( fData,fFunc); }

	// effective points used in the fit	// effective points used in the fit
	virtual unsigned int NFitPoints() const { return fNEffPoints; }	virtual unsigned int NFitPoints() const { return fNEffPoints; }

	/// i-th likelihood element and its gradient	/// i-th likelihood element and its gradient
	virtual double DataElement(const double * x, unsigned int i, double * g) const {	virtual double DataElement(const double * x, unsigned int i, double * g) const {

		if (i==0) this->UpdateNCalls();
	return FitUtil::EvaluatePoissonBinPdf(fFunc, fData, x, i, g);	return FitUtil::EvaluatePoissonBinPdf(fFunc, fData, x, i, g);
	}	}

	/// evaluate gradient	/// evaluate gradient
	virtual void Gradient(const double x, double g) const {	virtual void Gradient(const double x, double g) const {
	// evaluate the chi2 gradient	// evaluate the chi2 gradient
	FitUtil::EvaluatePoissonLogLGradient(fFunc, fData, x, g );	FitUtil::EvaluatePoissonLogLGradient(fFunc, fData, x, g );
	}	}

	/// get type of fit method function	/// get type of fit method function

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

	Polynomial.h	Polynomial.h

	// @(#)root/mathmore:$Id: Polynomial.h 32630 2010-03-17 09:59:26Z moneta $	// @(#)root/mathmore:$Id: Polynomial.h 37160 2010-12-01 21:52:04Z moneta $
	// Authors: L. Moneta, A. Zsenei 08/2005	// Authors: L. Moneta, A. Zsenei 08/2005

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *
	* *	* *
	* This library is free software; you can redistribute it and/or *	* This library is free software; you can redistribute it and/or *
	* modify it under the terms of the GNU General Public License *	* modify it under the terms of the GNU General Public License *
	* as published by the Free Software Foundation; either version 2 *	* as published by the Free Software Foundation; either version 2 *
	* of the License, or (at your option) any later version. *	* of the License, or (at your option) any later version. *

	skipping to change at line 66	skipping to change at line 66
	Implements both the Parameteric function interface and the gradient in terface	Implements both the Parameteric function interface and the gradient in terface
	since it provides the analytical gradient with respect to x	since it provides the analytical gradient with respect to x

	@ingroup ParamFunc	@ingroup ParamFunc
	*/	*/

	class Polynomial : public ParamFunction<IParamGradFunction>,	class Polynomial : public ParamFunction<IParamGradFunction>,
	public IGradientOneDim	public IGradientOneDim
	{	{


	typedef ParamFunction<IParamGradFunction> ParFunc;

	public:	public:


		typedef ParamFunction<IParamGradFunction> ParFunc;
	/**	/**
	Construct a Polynomial function of order n.	Construct a Polynomial function of order n.
	The number of Parameters is n+1.	The number of Parameters is n+1.
	*/	*/

	Polynomial(unsigned int n = 0);	Polynomial(unsigned int n = 0);

	/**	/**
	Construct a Polynomial of degree 1 : a*x + b	Construct a Polynomial of degree 1 : a*x + b
	*/	*/

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

	Property.h	Property.h

	skipping to change at line 38	skipping to change at line 38
	#define G__BIT_ISABSTRACT 0x00000040	#define G__BIT_ISABSTRACT 0x00000040
	#define G__BIT_ISVIRTUAL 0x00000080	#define G__BIT_ISVIRTUAL 0x00000080
	#define G__BIT_ISPUREVIRTUAL 0x00000100	#define G__BIT_ISPUREVIRTUAL 0x00000100
	#define G__BIT_ISPUBLIC 0x00000200	#define G__BIT_ISPUBLIC 0x00000200
	#define G__BIT_ISPROTECTED 0x00000400	#define G__BIT_ISPROTECTED 0x00000400
	#define G__BIT_ISPRIVATE 0x00000800	#define G__BIT_ISPRIVATE 0x00000800
	#define G__BIT_ISPOINTER 0x00001000	#define G__BIT_ISPOINTER 0x00001000
	#define G__BIT_ISARRAY 0x00002000	#define G__BIT_ISARRAY 0x00002000
	#define G__BIT_ISSTATIC 0x00004000	#define G__BIT_ISSTATIC 0x00004000
	#define G__BIT_ISDEFAULT 0x00008000	#define G__BIT_ISDEFAULT 0x00008000


	#define G__BIT_ISREFERENCE 0x00010000	#define G__BIT_ISREFERENCE 0x00010000
	#define G__BIT_ISDIRECTINHERIT 0x00020000	#define G__BIT_ISDIRECTINHERIT 0x00020000
	#define G__BIT_ISCCOMPILED 0x00040000	#define G__BIT_ISCCOMPILED 0x00040000
	#define G__BIT_ISCPPCOMPILED 0x00080000	#define G__BIT_ISCPPCOMPILED 0x00080000
	#define G__BIT_ISCOMPILED 0x000c0000	#define G__BIT_ISCOMPILED 0x000c0000
	#define G__BIT_ISBYTECODE 0x02000000	#define G__BIT_ISBYTECODE 0x02000000
	#define G__BIT_ISCONSTANT 0x00100000	#define G__BIT_ISCONSTANT 0x00100000
	#define G__BIT_ISVIRTUALBASE 0x00200000	#define G__BIT_ISVIRTUALBASE 0x00200000
	#define G__BIT_ISPCONSTANT 0x00400000	#define G__BIT_ISPCONSTANT 0x00400000
	#define G__BIT_ISMETHCONSTANT 0x10000000 // method is const	#define G__BIT_ISMETHCONSTANT 0x10000000 // method is const

	#define G__BIT_ISGLOBALVAR 0x00800000	#define G__BIT_ISGLOBALVAR 0x00800000
	#define G__BIT_ISLOCALVAR 0x01000000	#define G__BIT_ISLOCALVAR 0x01000000
	#define G__BIT_ISEXPLICIT 0x04000000	#define G__BIT_ISEXPLICIT 0x04000000
	#define G__BIT_ISNAMESPACE 0x08000000	#define G__BIT_ISNAMESPACE 0x08000000


		#define G__BIT_ISUSINGVARIABLE 0x20000000

	/* ECF enhancement ClassProperty() */	/* ECF enhancement ClassProperty() */

	#define G__CLS_VALID 0x00000001	#define G__CLS_VALID 0x00000001

	#define G__CLS_HASEXPLICITCTOR 0x00000010	#define G__CLS_HASEXPLICITCTOR 0x00000010
	#define G__CLS_HASIMPLICITCTOR 0x00000020	#define G__CLS_HASIMPLICITCTOR 0x00000020
	#define G__CLS_HASCTOR 0x00000030	#define G__CLS_HASCTOR 0x00000030
	#define G__CLS_HASDEFAULTCTOR 0x00000040	#define G__CLS_HASDEFAULTCTOR 0x00000040
	#define G__CLS_HASASSIGNOPR 0x00000080	#define G__CLS_HASASSIGNOPR 0x00000080


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

	RConfigOptions.h	RConfigOptions.h
	#ifndef ROOT_RConfigOptions	#ifndef ROOT_RConfigOptions
	#define ROOT_RConfigOptions	#define ROOT_RConfigOptions


	#define R__CONFIGUREOPTIONS "QTDIR=/afs/cern.ch/sw/lcg/external/qt/4.6.3/	#define R__CONFIGUREOPTIONS "QTDIR=/afs/cern.ch/sw/lcg/external/qt/4.6.3/
	i686-slc5-gcc43-opt PYTHONDIR=/afs/cern.ch/sw/lcg/external/Python/2.6.5/i68	i686-slc5-gcc43-opt PYTHONDIR=/afs/cern.ch/sw/lcg/external/Python/2.6.5/i68
	6-slc5-gcc43-opt --fail-on-missing --enable-cintex --enable-explicitlink --	6-slc5-gcc43-opt linux --fail-on-missing --enable-cintex --enable-explicitl
	enable-gdml --enable-genvector --enable-krb5 --enable-mathmore --enable-min	ink --enable-gdml --enable-genvector --enable-krb5 --enable-mathmore --enab
	uit2 --enable-mysql --enable-oracle --enable-python --enable-qt --enable-qt	le-minuit2 --enable-mysql --enable-oracle --enable-python --enable-qt --ena
	gsi --enable-reflex --enable-roofit --enable-table --enable-unuran --with-c	ble-qtgsi --enable-reflex --enable-roofit --enable-table --enable-unuran --
	astor-incdir=/afs/cern.ch/sw/lcg/external/castor/2.1.8-10/i686-slc5-gcc43-o	with-castor-incdir=/afs/cern.ch/sw/lcg/external/castor/2.1.8-10/i686-slc5-g
	pt/usr/include/shift --with-castor-libdir=/afs/cern.ch/sw/lcg/external/cast	cc43-opt/usr/include/shift --with-castor-libdir=/afs/cern.ch/sw/lcg/externa
	or/2.1.8-10/i686-slc5-gcc43-opt/usr/lib --with-cern-libdir=/afs/cern.ch/sw/	l/castor/2.1.8-10/i686-slc5-gcc43-opt/usr/lib --with-cern-libdir=/afs/cern.
	lcg/external/cernlib/2006a/i686-slc5-gcc43-opt/lib --with-dcap-libdir=/afs/	ch/sw/lcg/external/cernlib/2006a/i686-slc5-gcc43-opt/lib --with-dcap-libdir
	cern.ch/sw/lcg/external/dcache_client/1.9.3p1/i686-slc5-gcc43-opt/dcap/lib	=/afs/cern.ch/sw/lcg/external/dcache_client/1.9.3p1/i686-slc5-gcc43-opt/dca
	--with-dcap-incdir=/afs/cern.ch/sw/lcg/external/dcache_client/1.9.3p1/i686-	p/lib --with-dcap-incdir=/afs/cern.ch/sw/lcg/external/dcache_client/1.9.3p1
	slc5-gcc43-opt/dcap/include --with-fftw3-incdir=/afs/cern.ch/sw/lcg/externa	/i686-slc5-gcc43-opt/dcap/include --with-fftw3-incdir=/afs/cern.ch/sw/lcg/e
	l/fftw3/3.1.2/i686-slc5-gcc43-opt/include --with-fftw3-libdir=/afs/cern.ch/	xternal/fftw3/3.1.2/i686-slc5-gcc43-opt/include --with-fftw3-libdir=/afs/ce
	sw/lcg/external/fftw3/3.1.2/i686-slc5-gcc43-opt/lib --with-gccxml=/afs/cern	rn.ch/sw/lcg/external/fftw3/3.1.2/i686-slc5-gcc43-opt/lib --with-gccxml=/af
	.ch/sw/lcg/external/gccxml/0.9.0_20100114/i686-slc5-gcc43-opt/bin --with-gf	s/cern.ch/sw/lcg/external/gccxml/0.9.0_20100114/i686-slc5-gcc43-opt/bin --w
	al-libdir=/afs/cern.ch/sw/lcg/external/Grid/gfal/1.11.8-2/i686-slc5-gcc43-o	ith-gfal-libdir=/afs/cern.ch/sw/lcg/external/Grid/gfal/1.11.8-2/i686-slc5-g
	pt/lib --with-gfal-incdir=/afs/cern.ch/sw/lcg/external/Grid/gfal/1.11.8-2/i	cc43-opt/lib --with-gfal-incdir=/afs/cern.ch/sw/lcg/external/Grid/gfal/1.11
	686-slc5-gcc43-opt/include --with-gsl-incdir=/afs/cern.ch/sw/lcg/external/G	.8-2/i686-slc5-gcc43-opt/include --with-gsl-incdir=/afs/cern.ch/sw/lcg/exte
	SL/1.10/i686-slc5-gcc43-opt/include --with-gsl-libdir=/afs/cern.ch/sw/lcg/e	rnal/GSL/1.10/i686-slc5-gcc43-opt/include --with-gsl-libdir=/afs/cern.ch/sw
	xternal/GSL/1.10/i686-slc5-gcc43-opt/lib --with-mysql-incdir=/afs/cern.ch/s	/lcg/external/GSL/1.10/i686-slc5-gcc43-opt/lib --with-mysql-incdir=/afs/cer
	w/lcg/external/mysql/5.1.45/i686-slc5-gcc43-opt/include/mysql --with-mysql-	n.ch/sw/lcg/external/mysql/5.1.45/i686-slc5-gcc43-opt/include/mysql --with-
	libdir=/afs/cern.ch/sw/lcg/external/mysql/5.1.45/i686-slc5-gcc43-opt/lib/my	mysql-libdir=/afs/cern.ch/sw/lcg/external/mysql/5.1.45/i686-slc5-gcc43-opt/
	sql --with-oracle-incdir=/afs/cern.ch/sw/lcg/external/oracle/11.2.0.1.0p2/i	lib/mysql --with-oracle-incdir=/afs/cern.ch/sw/lcg/external/oracle/11.2.0.1
	686-slc5-gcc43-opt/include --with-oracle-libdir=/afs/cern.ch/sw/lcg/externa	.0p2/i686-slc5-gcc43-opt/include --with-oracle-libdir=/afs/cern.ch/sw/lcg/e
	l/oracle/11.2.0.1.0p2/i686-slc5-gcc43-opt/lib --with-rfio-incdir=/afs/cern.	xternal/oracle/11.2.0.1.0p2/i686-slc5-gcc43-opt/lib --with-rfio-incdir=/afs
	ch/sw/lcg/external/castor/2.1.8-10/i686-slc5-gcc43-opt/usr/include/shift --	/cern.ch/sw/lcg/external/castor/2.1.8-10/i686-slc5-gcc43-opt/usr/include/sh
	with-rfio-libdir=/afs/cern.ch/sw/lcg/external/castor/2.1.8-10/i686-slc5-gcc	ift --with-rfio-libdir=/afs/cern.ch/sw/lcg/external/castor/2.1.8-10/i686-sl
	43-opt/usr/lib --with-pythia6-libdir=/afs/cern.ch/user/b/bellenot/scratch0/	c5-gcc43-opt/usr/lib --with-pythia6-libdir=/afs/cern.ch/sw/lcg/external/MCG
	dist/pythia6/i686-slc5-gcc43-opt --with-pythia8-incdir=/afs/cern.ch/user/b/	enerators/pythia6/421.2/i686-slc5-gcc43-opt/lib --with-pythia8-incdir=/afs/
	bellenot/scratch0/dist/pythia8/i686-slc5-gcc43-opt/include --with-pythia8-l	cern.ch/sw/lcg/external/MCGenerators/pythia8/130/i686-slc5-gcc43-opt/includ
	ibdir=/afs/cern.ch/user/b/bellenot/scratch0/dist/pythia8/i686-slc5-gcc43-op	e --with-pythia8-libdir=/afs/cern.ch/sw/lcg/external/MCGenerators/pythia8/1
	t/lib --with-gviz-incdir=/build/bellenot/libraries/i686-slc5-gcc43-opt/grap	30/i686-slc5-gcc43-opt/lib --with-gviz-incdir=/afs/cern.ch/sw/lcg/external/
	hviz-2.24.0/include/graphviz --with-gviz-libdir=/build/bellenot/libraries/i	graphviz/2.24.0/i686-slc5-gcc43-opt/include/graphviz --with-gviz-libdir=/af
	686-slc5-gcc43-opt/graphviz-2.24.0/lib"	s/cern.ch/sw/lcg/external/graphviz/2.24.0/i686-slc5-gcc43-opt/lib"
	#define R__CONFIGUREFEATURES "asimage astiff builtin_afterimage builtin_ft	#define R__CONFIGUREFEATURES "asimage astiff builtin_afterimage builtin_ft
	gl builtin_glew castor cintex editline dcache exceptions explicitlink fftw3	gl builtin_glew builtin_pcre castor cintex editline dcache exceptions expli
	gviz gdml genvector gfal krb5 ldap mathmore memstat minuit2 mysql opengl o	citlink fftw3 gviz gdml genvector gfal krb5 ldap mathmore memstat minuit2 m
	racle pythia6 pythia8 python qt qtgsi reflex roofit rfio shadowpw shared ss	ysql opengl oracle pgsql pythia8 python qt qtgsi reflex roofit rfio shadowp
	l table tmva unuran x11 xft xml xrootd thread"	w shared ssl table tmva unuran x11 xft xml xrootd thread"

	#endif	#endif

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

	Results.h	Results.h

	// @(#)root/tmva $Id: Results.h 35727 2010-09-24 21:41:20Z stelzer $	// @(#)root/tmva $Id: Results.h 36966 2010-11-26 09:50:13Z evt $
	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : Results *	* Class : Results *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Base-class for result-vectors *	* Base-class for result-vectors *

	skipping to change at line 81	skipping to change at line 81

	// getters	// getters
	Types::ETreeType GetTreeType() const { return fTreeType; }	Types::ETreeType GetTreeType() const { return fTreeType; }
	const DataSetInfo* GetDataSetInfo() const { return fDsi; }	const DataSetInfo* GetDataSetInfo() const { return fDsi; }
	DataSet* GetDataSet() const { return fDsi->GetDataSet( ); }	DataSet* GetDataSet() const { return fDsi->GetDataSet( ); }
	TList* GetStorage() const { return fStorage; }	TList* GetStorage() const { return fStorage; }
	TObject* GetObject(const TString & alias) const;	TObject* GetObject(const TString & alias) const;
	TH1* GetHist(const TString & alias) const;	TH1* GetHist(const TString & alias) const;
	virtual Types::EAnalysisType GetAnalysisType() { return Types::kNoAn alysisType; }	virtual Types::EAnalysisType GetAnalysisType() { return Types::kNoAn alysisType; }


		// delete all stored data
		void Delete();

	virtual const std::vector< Float_t >& operator [] ( Int_t ievt ) con st = 0;	virtual const std::vector< Float_t >& operator [] ( Int_t ievt ) con st = 0;

	private:	private:
	Types::ETreeType fTreeType; //! tree type for this res ult	Types::ETreeType fTreeType; //! tree type for this res ult
	const DataSetInfo* fDsi; //! a pointer to the datas etinfo-object	const DataSetInfo* fDsi; //! a pointer to the datas etinfo-object
	TList* fStorage; //! stores all the result- histograms	TList* fStorage; //! stores all the result- histograms
	std::map<TString, TObject> fHistAlias; //! internal map for quick access to stored histograms	std::map<TString, TObject> fHistAlias; //! internal map for quick access to stored histograms
	mutable MsgLogger* fLogger; // message logger	mutable MsgLogger* fLogger; // message logger
	MsgLogger& Log() const { return *fLogger; }	MsgLogger& Log() const { return *fLogger; }
	};	};

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