ROOT: headers diff between 5.34.05 and 5.34.06 versions

	BernsteinCorrection.h	BernsteinCorrection.h

	// @(#)root/roostats:$Id: BernsteinCorrection.h 39391 2011-05-26 09:51:59Z moneta $	// @(#)root/roostats:$Id: BernsteinCorrection.h 48991 2013-03-28 15:25:11Z rdm $
	// Author: Kyle Cranmer	// Author: Kyle Cranmer
	/*************************************************************************	/*************************************************************************
	* 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_BernsteinCorrection	#ifndef ROOSTATS_BernsteinCorrection

	skipping to change at line 41	skipping to change at line 41
	void CreateQSamplingDist(RooWorkspace* wks,	void CreateQSamplingDist(RooWorkspace* wks,
	const char* nominalName,	const char* nominalName,
	const char* varName,	const char* varName,
	const char* dataName,	const char* dataName,
	TH1F, TH1F,	TH1F, TH1F,
	Int_t degree,	Int_t degree,
	Int_t nToys=500);	Int_t nToys=500);

	private:	private:
	Double_t fMaxCorrection; // maximum correction factor at any point	Double_t fMaxCorrection; // maximum correction factor at any point

	Double_t fTolerance; // probability to add an unecessary term	Double_t fTolerance; // probability to add an unnecessary term

	protected:	protected:
	ClassDef(BernsteinCorrection,1) // A utility to add polynomial corrrect ion terms to a model to improve the description of data.	ClassDef(BernsteinCorrection,1) // A utility to add polynomial corrrect ion terms to a model to improve the description of data.
	};	};
	}	}

	#endif	#endif

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

	ChebyshevPol.h	ChebyshevPol.h

	// @(#)root/mathcore:$Id: ChebyshevPol.h 48567 2013-02-14 08:59:17Z moneta $	// @(#)root/mathcore:$Id: ChebyshevPol.h 48704 2013-02-26 09:49:38Z rdm $
	// Author: L. Moneta, 11/2012	// Author: L. Moneta, 11/2012


	/**********************************************************************	/*************************************************************************
	* *	* Copyright (C) 1995-2012, Rene Brun and Fons Rademakers. *
	* Copyright (c) 2012 ROOT Foundation, CERN/PH-SFT *	* All rights reserved. *
	* *	* *
	* *	* For the licensing terms see $ROOTSYS/LICENSE. *
	**********************************************************************/	* For the list of contributors see $ROOTSYS/README/CREDITS. *
		*************************************************************************/
	/**
	Header file declaring functions for the evaluation of the Chebyshev pol	//////////////////////////////////////////////////////////////////////////
	ynomials	// //
	and the ChebyshevPol class which can be used for creating a TF1	// Header file declaring functions for the evaluation of the Chebyshev //
	*/	// polynomials and the ChebyshevPol class which can be used for //
		// creating a TF1. //
		// //
		//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_Math_ChebyshevPol	#ifndef ROOT_Math_ChebyshevPol
	#define ROOT_Math_ChebyshevPol	#define ROOT_Math_ChebyshevPol


		#if !defined(__CINT__)
		#include <sys/types.h>
		#endif
	#include <cstring>	#include <cstring>

	namespace ROOT {	namespace ROOT {

	namespace Math {	namespace Math {


	/// template recursive functions for defining evaluation of Chebishev polynomials	/// template recursive functions for defining evaluation of Chebyshev polynomials
	/// T_n(x) and the series S(x) = Sum_i c_i* T_i(x)	/// T_n(x) and the series S(x) = Sum_i c_i* T_i(x)
	namespace Chebyshev {	namespace Chebyshev {

	template<int N> double T(double x) {	template<int N> double T(double x) {
	return (2.0 * x * T<N-1>(x)) - T<N-2>(x);	return (2.0 * x * T<N-1>(x)) - T<N-2>(x);
	}	}


	template<> double T<0> (double ) { return 1;}	template<> double T<0> (double );
		template<> double T<1> (double x);
	template<> double T<1> (double x) { return x;}	template<> double T<2> (double x);
		template<> double T<3> (double x);
	template<> double T<2> (double x) { return 2.0xx -1;}

	template<> double T<3> (double x) { return 4.0xxx -3.0x;}

	template<int N> double Eval(double x, const double * c) {	template<int N> double Eval(double x, const double * c) {
	return c[N]*T<N>(x) + Eval<N-1>(x,c);	return c[N]*T<N>(x) + Eval<N-1>(x,c);
	}	}


	template<> double Eval<0> (double , const double *c) { return c[0]	template<> double Eval<0> (double , const double *c);
	;}	template<> double Eval<1> (double x, const double *c);
	template<> double Eval<1> (double x, const double *c) { return c[1	template<> double Eval<2> (double x, const double *c);
	]*x + c[0];}	template<> double Eval<3> (double x, const double *c);
	template<> double Eval<2> (double x, const double *c) { return c[2
	]Chebyshev::T<2>(x) + c[1]x + c[0];}
	template<> double Eval<3> (double x, const double *c) { return c[3
	]*Chebyshev::T<3>(x) + Eval<2>(x,c); }

	} // end namespace Chebyshev	} // end namespace Chebyshev

	// implementation of Chebyshev polynomials using all coefficients	// implementation of Chebyshev polynomials using all coefficients
	// needed for creating TF1 functions	// needed for creating TF1 functions

	double Chebyshev0(double , double c0) {	inline double Chebyshev0(double , double c0) {
	return c0;	return c0;
	}	}

	double Chebyshev1(double x, double c0, double c1) {	inline double Chebyshev1(double x, double c0, double c1) {
	return c0 + c1*x;	return c0 + c1*x;
	}	}

	double Chebyshev2(double x, double c0, double c1, double c2) {	inline double Chebyshev2(double x, double c0, double c1, double c2) {
	return c0 + c1x + c2(2.0xx - 1.0);	return c0 + c1x + c2(2.0xx - 1.0);
	}	}

	double Chebyshev3(double x, double c0, double c1, double c2, double c 3) {	inline double Chebyshev3(double x, double c0, double c1, double c2, d ouble c3) {
	return c3*Chebyshev::T<3>(x) + Chebyshev2(x,c0,c1,c2);	return c3*Chebyshev::T<3>(x) + Chebyshev2(x,c0,c1,c2);
	}	}

	double Chebyshev4(double x, double c0, double c1, double c2, double c 3, double c4) {	inline double Chebyshev4(double x, double c0, double c1, double c2, d ouble c3, double c4) {
	return c4*Chebyshev::T<4>(x) + Chebyshev3(x,c0,c1,c2,c3);	return c4*Chebyshev::T<4>(x) + Chebyshev3(x,c0,c1,c2,c3);
	}	}

	double Chebyshev5(double x, double c0, double c1, double c2, double c 3, double c4, double c5) {	inline double Chebyshev5(double x, double c0, double c1, double c2, d ouble c3, double c4, double c5) {
	return c5*Chebyshev::T<5>(x) + Chebyshev4(x,c0,c1,c2,c3,c4);	return c5*Chebyshev::T<5>(x) + Chebyshev4(x,c0,c1,c2,c3,c4);
	}	}

	// implementation of Chebyshev polynomial with run time parameter	// implementation of Chebyshev polynomial with run time parameter

	double ChebyshevN(unsigned int n, double x, const double * c) {	inline double ChebyshevN(unsigned int n, double x, const double * c) {

	if (n == 0) return Chebyshev0(x,c[0]);	if (n == 0) return Chebyshev0(x,c[0]);
	if (n == 1) return Chebyshev1(x,c[0],c[1]);	if (n == 1) return Chebyshev1(x,c[0],c[1]);
	if (n == 2) return Chebyshev2(x,c[0],c[1],c[2]);	if (n == 2) return Chebyshev2(x,c[0],c[1],c[2]);
	if (n == 3) return Chebyshev3(x,c[0],c[1],c[2],c[3]);	if (n == 3) return Chebyshev3(x,c[0],c[1],c[2],c[3]);
	if (n == 4) return Chebyshev4(x,c[0],c[1],c[2],c[3],c[4]);	if (n == 4) return Chebyshev4(x,c[0],c[1],c[2],c[3],c[4]);
	if (n == 5) return Chebyshev5(x,c[0],c[1],c[2],c[3],c[4],c[5]);	if (n == 5) return Chebyshev5(x,c[0],c[1],c[2],c[3],c[4],c[5]);

	/* do not use recursive formula	/* do not use recursive formula
	(2.0 * x * Tn(n - 1, x)) - Tn(n - 2, x) ;	(2.0 * x * Tn(n - 1, x)) - Tn(n - 2, x) ;

	skipping to change at line 122	skipping to change at line 126

	double operator() (const double x, const double coeff) {	double operator() (const double x, const double coeff) {
	return ChebyshevN(fOrder, x[0], coeff);	return ChebyshevN(fOrder, x[0], coeff);
	}	}
	private:	private:
	unsigned int fOrder;	unsigned int fOrder;
	};	};

	} // end namespace Math	} // end namespace Math


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

	#endif // ROOT_Math_Chebyshev	#endif // ROOT_Math_Chebyshev

End of changes. 14 change blocks.
	37 lines changed or deleted	36 lines changed or added

	CollectionProxy.h	CollectionProxy.h

	// @(#)root/reflex:$Id: CollectionProxy.h 36698 2010-11-16 16:40:22Z axel $	// @(#)root/reflex:$Id: CollectionProxy.h 48993 2013-03-28 16:48:14Z pcanal $
	// 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>

		#include <assert.h>

	// 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 3	#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;
	template <class K, class T, class R, class A> class map;	template <class K, class T, class R, class A> class map;
	template <class K, class T, class R, class A> class multimap;	template <class K, class T, class R, class A> class multimap;
	template <class T> class allocator;	template <class T> class allocator;
	}	}
	// Hash map forward declarations	// Hash map forward declarations
	#if defined(__GNUC__)	#if defined(__GNUC__)
	namespace __gnu_cxx { // GNU GCC	namespace __gnu_cxx { // GNU GCC

	template <class T, class F, class E, class A> class hash_set;	template <class T, class F, class E, class A> class hash_set;
	template <class T, class F, class E, class A> class hash_multiset;	template <class T, class F, class E, class A> class hash_multiset;
	template <class K, class T, class F, class E, class A> class hash_map;	template <class K, class T, class F, class E, class A> class hash_map;
	template <class K, class T, class F, class E, class A> class hash_multimap;	template <class K, class T, class F, class E, class A> class hash_multim
		ap;
	}	}
	#elif defined(_WIN32)	#elif defined(_WIN32)
	namespace stdext { // Visual C++	namespace stdext { // Visual C++

	template <class K, class T, class A> class hash_set;	template <class K, class T, class A> class hash_set;
	template <class K, class T, class A> class hash_multiset;	template <class K, class T, class A> class hash_multiset;
	template <class K, class T, class R, class A> class hash_map;	template <class K, class T, class R, class A> class hash_map;
	template <class K, class T, class R, class A> class hash_multimap;	template <class K, class T, class R, class A> class hash_multimap;
	}	}
	#endif	#endif

	namespace Reflex {	namespace Reflex {
	#ifndef __CINT__	#ifndef __CINT__

	struct EnvironBase {	struct EnvironBase {
	EnvironBase(): fIdx(0),	EnvironBase(): fIdx(0),

	fSize(0),	fSize(0),
	fObject(0),	fObject(0),
	fStart(0),	fStart(0),
	fTemp(0),	fTemp(0),
	fDeleteTemp(false),	fDeleteTemp(false),
	fRefSize(1),	fRefSize(1),
	fSpace(0) {	fSpace(0) {
	// fprintf("Running default constructor on %p\n",this);	// fprintf("Running default constructor on %p\n",this);
	}	}


	virtual ~EnvironBase() {}	virtual ~EnvironBase() {}


	size_t fIdx;	size_t fIdx;
	size_t fSize;	size_t fSize;
	void* fObject;	void* fObject;
	void* fStart;	void* fStart;
	void* fTemp;	void* fTemp;
	bool fDeleteTemp;	bool fDeleteTemp;
	int fRefSize;	int fRefSize;
	size_t fSpace;	size_t fSpace;
	};	};
	template <typename T> struct Environ: public EnvironBase {
	typedef T Iter_t;	template <typename T> struct Environ: public EnvironBase {
	Iter_t fIterator;	typedef T Iter_t;
	T&	Iter_t fIterator;
	iter() { return fIterator; }	T&
		iter() { return fIterator; }
	static void*
	Create() {	static void*
	return new Environ();	Create() {
	}	return new Environ();
		}
	};	};
	#else	#else

	struct EnvironBase;	struct EnvironBase;
	template <typename T> struct Environ;	template <typename T> struct Environ;
	#endif	#endif


	template <typename T> struct Address {	template <typename T> struct Address {
	static void*	static void*
	address(T ref) {	address(T ref) {
	return (void*)& ref;	return (void*)& ref;
	}	}
		};

		// Same value as TVirtualCollectionProxy.
		static const unsigned int fgIteratorArenaSize = 16; // greater than size
		of(void*) + sizeof(UInt_t)


	};	/** @class template TCollectionProxyInfo::IteratorValue
		*
		* Small helper to encapsulate whether to return the value
		* pointed to by the iterator or its address.
		*
		**/

		template <typename Cont_t, typename value> struct IteratorValue {
		static void* get(typename Cont_t::iterator &iter) {
		return (void)&(iter);
		}
		};

		template <typename Cont_t, typename value_ptr> struct IteratorValue<C
		ont_t, value_ptr*> {
		static void* get(typename Cont_t::iterator &iter) {
		return (void)(iter);
		}
		};

		template <> struct IteratorValue<std::vector<bool>,bool> {
		static void* get(std::vector<bool>::iterator & /* iter */) {
		return 0;
		}
		};

		/** @class template TCollectionProxyInfo::Iterators
		*
		* Small helper to implement the function to create,access and destroy
		* iterators.
		*
		**/

		template <typename Cont_t, bool large = false>
		struct Iterators {
		typedef Cont_t *PCont_t;
		typedef typename Cont_t::iterator iterator;

		static void create(void coll, void begin_arena, void *end_aren
		a) {
		PCont_t c = PCont_t(coll);
		new (*begin_arena) iterator(c->begin());
		new (*end_arena) iterator(c->end());
		}
		static void* copy(void dest_arena, const void source_ptr) {
		iterator source = (iterator )(source_ptr);
		new (dest_arena) iterator(*source);
		return dest_arena;
		}
		static void* next(void iter_loc, const void end_loc) {
		iterator end = (iterator )(end_loc);
		iterator iter = (iterator )(iter_loc);
		if (iter != end) {
		void *result = IteratorValue<Cont_t, typename Cont_t::value_
		type>::get(*iter);
		++(*iter);
		return result;
		}
		return 0;
		}
		static void destruct1(void *iter_ptr) {
		iterator start = (iterator )(iter_ptr);
		start->~iterator();
		}
		static void destruct2(void begin_ptr, void end_ptr) {
		iterator start = (iterator )(begin_ptr);
		iterator end = (iterator )(end_ptr);
		start->~iterator();
		end->~iterator();
		}
		};

		// For Vector we take an extra short cut to avoid derefencing
		// the iterator all the time and redefine the 'address' of the
		// iterator as the iterator itself. This requires special handling
		// in the looper (see TStreamerInfoAction) but is much faster.
		template <typename T> struct Iterators<std::vector<T>, false> {
		typedef std::vector<T> Cont_t;
		typedef Cont_t *PCont_t;
		typedef typename Cont_t::iterator iterator;

		static void create(void coll, void begin_arena, void *end_aren
		a) {
		PCont_t c = PCont_t(coll);
		if (c->empty()) {
		*begin_arena = 0;
		*end_arena = 0;
		return;
		}
		begin_arena = &(c->begin());
		#ifdef R__VISUAL_CPLUSPLUS
		end_arena = &((c->end()-1)) + 1; // On windows we can not der
		erence the end iterator at all.
		#else
		// coverity[past_the_end] Safe on other platforms
		end_arena = &(c->end());
		#endif
		}
		static void* copy(void dest, const void source) {
		(void)dest = (void**)source;
		return dest;
		}
		static void* next(void * /* iter_loc /, const void /* end_loc *
		/) {
		// Should not be used.
		assert(0 && "Intentionally not implemented, do not use.");
		return 0;
		}
		static void destruct1(void * /* iter_ptr */) {
		// Nothing to do
		}
		static void destruct2(void * /* begin_ptr /, void /* end_ptr */
		) {
		// Nothing to do
		}
		};

		template <> struct Iterators<std::vector<bool>, false> {
		typedef std::vector<bool> Cont_t;
		typedef Cont_t *PCont_t;
		typedef Cont_t::iterator iterator;

		static void create(void coll, void begin_arena, void *end_aren
		a) {
		PCont_t c = PCont_t(coll);
		new (*begin_arena) iterator(c->begin());
		new (*end_arena) iterator(c->end());
		}
		static void* copy(void dest_arena, const void source_ptr) {
		iterator source = (iterator )(source_ptr);
		new (dest_arena) iterator(*source);
		return dest_arena;
		}
		static void* next(void iter_loc, const void end_loc) {
		iterator end = (iterator )(end_loc);
		iterator iter = (iterator )(iter_loc);
		if (iter != end) {
		void *result = IteratorValue<Cont_t, Cont_t::value_type>::ge
		t(*iter);
		++(*iter);
		return result;
		}
		return 0;
		}
		static void destruct1(void *iter_ptr) {
		iterator start = (iterator )(iter_ptr);
		start->~iterator();
		}
		static void destruct2(void begin_ptr, void end_ptr) {
		iterator start = (iterator )(begin_ptr);
		iterator end = (iterator )(end_ptr);
		start->~iterator();
		end->~iterator();
		}
		};

		template <typename Cont_t> struct Iterators<Cont_t, /* large= */ true
		> {
		typedef Cont_t *PCont_t;
		typedef typename Cont_t::iterator iterator;

		static void create(void coll, void begin_arena, void *end_aren
		a) {
		PCont_t c = PCont_t(coll);
		*begin_arena = new iterator(c->begin());
		*end_arena = new iterator(c->end());
		}
		static void* copy(void * /dest_arena/, const void *source_ptr) {
		iterator source = (iterator )(source_ptr);
		void iter = new iterator(source);
		return iter;
		}
		static void* next(void iter_loc, const void end_loc) {
		iterator end = (iterator )(end_loc);
		iterator iter = (iterator )(iter_loc);
		if (iter != end) {
		void *result = IteratorValue<Cont_t, typename Cont_t::value_
		type>::get(*iter);
		++(*iter);
		return result;
		}
		return 0;
		}
		static void destruct1(void *begin_ptr) {
		iterator start = (iterator )(begin_ptr);
		delete start;
		}
		static void destruct2(void begin_ptr, void end_ptr) {
		iterator start = (iterator )(begin_ptr);
		iterator end = (iterator )(end_ptr);
		delete start;
		delete end;
		}
		};


	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	#ifdef _KCC // KAI compiler

	typedef Address<typename T::value_type&> Address_t;	typedef Address<typename T::value_type&> Address_t;
	#else	#else

	typedef Address<typename T::const_reference> Address_t;	typedef Address<typename T::const_reference> Address_t;
	#endif	#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) {
	return PCont_t(PEnv_t(ptr)->fObject);	return PCont_t(PEnv_t(ptr)->fObject);
	}	}

	static void*	static void*
	size(void* env) {	size(void* env) {
	PEnv_t e = PEnv_t(env);	PEnv_t e = PEnv_t(env);
	e->fSize = PCont_t(e->fObject)->size();	e->fSize = PCont_t(e->fObject)->size();
	return &e->fSize;	return &e->fSize;
	}	}

	static void*	static void*
	clear(void* env) {	clear(void* env) {
	object(env)->clear();	object(env)->clear();
	return 0;	return 0;
	}	}

	static void*	static void*
	first(void* env) {	first(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);
	// 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_t::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->fIdx) {}


	// 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_t::address(ref);	return Address_t::address(ref);
	}	}


	static void*	static void*
	construct(void* what, size_t size) {	construct(void* what, size_t size) {
	PValue_t m = PValue_t(what);	PValue_t m = PValue_t(what);

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

		static void*
		collect(void* coll, void *array) {
		PCont_t c = PCont_t(coll);
		PValue_t m = PValue_t(array);

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

		static void
		destruct(void* what, size_t size) {
		PValue_t m = PValue_t(what);

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

		static const bool fgLargeIterator = sizeof(typename Cont_t::iterat
		or) > fgIteratorArenaSize;
		typedef Iterators<Cont_t,fgLargeIterator> Iterators_t;

		};

		/** @class TCollectionProxy::Map TCollectionProxy.h TCollectionProxy.h
		*
		* Small helper to encapsulate all necessary data accesses for
		* containers like vector, list, deque
		*
		* @author M.Frank
		* @version 1.0
		* @date 10/10/2004
		*/
		template <class T> struct Pushback: public CollType<T> {
		typedef T Cont_t;
		typedef typename T::iterator Iter_t;
		typedef typename T::value_type Value_t;
		typedef Environ<Iter_t> Env_t;
		typedef Env_t* PEnv_t;
		typedef Cont_t* PCont_t;
		typedef Value_t* PValue_t;
		static void resize(void* obj, size_t n) {
		PCont_t c = PCont_t(obj);
		c->resize(n);
	}	}

	return 0;
	}

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


	for (Iter_t i = c->begin(); i != c->end(); ++i, ++m) {	static void*
	::new (m) Value_t(*i);	feed(voidfrom,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->push_back(*m);
		}
		return 0;
	}	}

	return 0;
	}

	static void
	destruct(void* what, size_t size) {
	PValue_t m = PValue_t(what);


	for (size_t i = 0; i < size; ++i, ++m) {	static int
	m->~Value_t();	value_offset() {
		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 set, multiset etc.
	*	*
	* @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 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 resize(void* obj, size_t n) {
	PCont_t c = PCont_t(obj);	static void*
	c->resize(n);	feed(voidfrom,voidto,size_t size) {
	}	PValue_t m = PValue_t(from);
		PCont_t c = PCont_t(to);
	static void*
	feed(voidfrom,void to,size_t size) {	for (size_t i = 0; i < size; ++i, ++m) {
	PValue_t m = PValue_t(from);	c->insert(*m);
	PCont_t c = PCont_t(to);	}
		return 0;
	for (size_t i = 0; i < size; ++i, ++m) {
	c->push_back(*m);
	}	}

	return 0;
	}

	static int
	value_offset() {
	return 0;
	}


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


	/** @class TCollectionProxy::Map TCollectionProxy.h TCollectionProxy.h	static int
	*	value_offset() {
	* Small helper to encapsulate all necessary data accesses for	return 0;
	* containers like set, multiset etc.
	*
	* @author M.Frank
	* @version 1.0
	* @date 10/10/2004
	*/
	template <class T> struct Insert: public CollType<T> {
	typedef T Cont_t;
	typedef typename T::iterator Iter_t;
	typedef typename T::value_type Value_t;
	typedef Environ<Iter_t> Env_t;
	typedef Env_t* PEnv_t;
	typedef Cont_t* PCont_t;
	typedef Value_t* PValue_t;

	static void*
	feed(voidfrom,voidto,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->insert(*m);
	}	}

	return 0;
	}


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


	static int	/** @class TCollectionProxy::Map TCollectionProxy.h TCollectionProxy.h
	value_offset() {	*
	return 0;	* Small helper to encapsulate all necessary data accesses for
	}	* containers like Set, multiset etc.
		*
	};	* @author M.Frank
		* @version 1.0
	/** @class TCollectionProxy::Map TCollectionProxy.h TCollectionProxy.h	* @date 10/10/2004
	*	*/
	* Small helper to encapsulate all necessary data accesses for	template <class T> struct MapInsert: public CollType<T> {
	* containers like Set, multiset etc.	typedef T Cont_t;
	*	typedef typename T::iterator Iter_t;
	* @author M.Frank	typedef typename T::value_type Value_t;
	* @version 1.0	typedef Environ<Iter_t> Env_t;
	* @date 10/10/2004	typedef Env_t* PEnv_t;
	*/	typedef Cont_t* PCont_t;
	template <class T> struct MapInsert: public CollType<T> {	typedef Value_t* PValue_t;
	typedef T Cont_t;
	typedef typename T::iterator Iter_t;	static void*
	typedef typename T::value_type Value_t;	feed(voidfrom,void to,size_t size) {
	typedef Environ<Iter_t> Env_t;	PValue_t m = PValue_t(from);
	typedef Env_t* PEnv_t;	PCont_t c = PCont_t(to);
	typedef Cont_t* PCont_t;
	typedef Value_t* PValue_t;	for (size_t i = 0; i < size; ++i, ++m) {
		c->insert(*m);
	static void*	}
	feed(voidfrom,void to,size_t size) {	return 0;
	PValue_t m = PValue_t(from);
	PCont_t c = PCont_t(to);

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

	return 0;
	}


	static void resize(void* /* obj */, size_t) {	static void resize(void* /* obj */, size_t) {
	}	}


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


	};	};

	#ifndef __CINT__	#ifndef __CINT__

	// Need specialization for boolean references due to stupid STL vector<bool	// Need specialization for boolean references due to stupid STL vector<b
	>	ool>
	template <> inline void* Reflex::Address<std::vector<bool, std::allocator<b	template <> inline void* Reflex::Address<std::vector<bool, std::allocato
	ool> >::const_reference	r<bool> >::const_reference
	>::address(std::vector<bool, std::allocator<bool> >::const_reference) {	>::address(std::vector<bool, std::allocator<bool> >::const_reference)
	return 0;	{
	}	return 0;
		}

	#endif	#endif

	}	}

	#include <vector>	#include <vector>
	namespace Reflex {	namespace Reflex {

	/** @class CollFuncTable	/** @class CollFuncTable
	*	*
	* 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,size_t);	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,size_t);	void* (construct_func)(void,size_t);
	void (destruct_func)(void,size_t);	void (destruct_func)(void,size_t);
	void* (feed_func)(void,void*,size_t);	void* (feed_func)(void,void*,size_t);
	void* (collect_func)(void);	void* (collect_func)(void,void*);
	void* (*create_env)();	void* (*create_env)();
	};
		// Set of function of direct iteration of the collections.
	template <typename T> struct CFTGenerator {	void (fCreateIterators)(void collection, void *begin_arena, void
	static CollFuncTable*	*end_arena);
	Generate() {	// begin_arena and end_arena should contain the location of memory ar
	typedef typename T::Value_t Value_t;	ena of size fgIteratorSize.
	typedef std::pair<Value_t, Value_t> Pair_t;	// If the collection iterator are of that size or less, the iterators
	Pair_t* ptr = (Pair_t*) 0x1000;	will be constructed in place in those location (new with placement)
	CollFuncTable* p = new CollFuncTable();	// Otherwise the iterators will be allocated via a regular new and th
	p->iter_size = sizeof(typename T::Iter_t);	eir address returned by modifying the value of begin_arena and end_arena.
	p->value_diff = ((char) &ptr->second) - ((char) &ptr->first);
	p->value_offset = T::value_offset();	void* (fCopyIterator)(void dest, const void *source);
	p->size_func = T::size;	// Copy the iterator source, into dest. dest should contain should
	p->first_func = T::first;	contain the location of memory arena of size fgIteratorSize.
	p->next_func = T::next;	// If the collection iterator are of that size or less, the iterator
	p->clear_func = T::clear;	will be constructed in place in this location (new with placement)
	p->resize_func = T::resize;	// Otherwise the iterator will be allocated via a regular new and its
	p->collect_func = T::collect;	address returned by modifying the value of dest.
	p->construct_func = T::construct;
	p->destruct_func = T::destruct;	void* (fNext)(void iter, const void *end);
	p->feed_func = T::feed;	// iter and end should be pointer to respectively an iterator to be i
	p->create_env = T::Env_t::Create;	ncremented and the result of colleciton.end()
	return p;	// 'Next' will increment the iterator 'iter' and return 0 if the iter
	} // Generate	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
	struct CFTNullGenerator {	// which case 'Next' will return the value of the pointer.
	static void*
	Void_func(void*) {	void (fDeleteSingleIterator)(void iter);
	return 0;	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.
		};

		template <typename T> struct CFTGenerator {
		static CollFuncTable*
		Generate() {
		typedef typename T::Value_t Value_t;
		typedef std::pair<Value_t, Value_t> Pair_t;
		Pair_t* ptr = (Pair_t*) 0x1000;
		CollFuncTable* p = new CollFuncTable();
		p->iter_size = sizeof(typename T::Iter_t);
		p->value_diff = ((char) &ptr->second) - ((char) &ptr->first);
		p->value_offset = T::value_offset();
		p->size_func = T::size;
		p->first_func = T::first;
		p->next_func = T::next;
		p->clear_func = T::clear;
		p->resize_func = T::resize;
		p->collect_func = T::collect;
		p->construct_func = T::construct;
		p->destruct_func = T::destruct;
		p->feed_func = T::feed;
		p->create_env = T::Env_t::Create;

		p->fCreateIterators = T::Iterators_t::create;
		p->fCopyIterator = T::Iterators_t::copy;
		p->fNext = T::Iterators_t::next;
		p->fDeleteSingleIterator = T::Iterators_t::destruct1;
		p->fDeleteTwoIterators = T::Iterators_t::destruct2;
		return p;
		} // Generate

		};
		struct CFTNullGenerator {
		static void*
		Void_func(void*) {
		return 0;
		}


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


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


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


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

	static CollFuncTable*	static void*
	Generate() {	Void_func3(void,void,size_t) { return 0; }
	CollFuncTable* p = new CollFuncTable();
	p->iter_size = 4;	static CollFuncTable*
	p->value_diff = 0;	Generate() {
	p->value_offset = 0;	CollFuncTable* p = new CollFuncTable();
	p->size_func = Void_func;	p->iter_size = 4;
	p->first_func = Void_func;	p->value_diff = 0;
	p->next_func = Void_func;	p->value_offset = 0;
	p->clear_func = Void_func;	p->size_func = Void_func;
	p->resize_func = Void_func2b;	p->first_func = Void_func;
	p->collect_func = Void_func;	p->next_func = Void_func;
	p->construct_func = Void_func2;	p->clear_func = Void_func;
	p->destruct_func = Void_func2b;	p->resize_func = Void_func2b;
	p->feed_func = Void_func3;	p->collect_func = Void_func2c;
	p->create_env = Void_func0;	p->construct_func = Void_func2;
	return p;	p->destruct_func = Void_func2b;
	} // Generate	p->feed_func = Void_func3;
		p->create_env = Void_func0;
	};
	// General proxy (dummy)	p->fCreateIterators = 0;
	template <typename A> struct Proxy {};	p->fCopyIterator = 0;
		p->fNext = 0;
	// Specialization for std::vector	p->fDeleteSingleIterator = 0;
	template <class T, class A> struct Proxy<std::vector<T, A> > {	p->fDeleteTwoIterators = 0;
	static CollFuncTable*
	Generate() {	return p;
	return CFTGenerator<Pushback<std::vector<T, A> > >::Generate();	} // Generate
	}
		};
		// General proxy (dummy)
		template <typename A> struct Proxy {};

		// Specialization for std::vector
		template <class T, class A> struct Proxy<std::vector<T, A> > {
		static CollFuncTable*
		Generate() {
		return CFTGenerator<Pushback<std::vector<T, A> > >::Generate();
		}


	};	};
	// Specialization for std::list	// Specialization for std::list
	template <class T, class A> struct Proxy<std::list<T, A> > {	template <class T, class A> struct Proxy<std::list<T, A> > {
	static CollFuncTable*	static CollFuncTable*
	Generate() {	Generate() {
	return CFTGenerator<Pushback<std::list<T, A> > >::Generate();	return CFTGenerator<Pushback<std::list<T, A> > >::Generate();
	}	}


	};	};
	// Specialization for std::deque	// Specialization for std::deque
	template <class T, class A> struct Proxy<std::deque<T, A> > {	template <class T, class A> struct Proxy<std::deque<T, A> > {
	static CollFuncTable*	static CollFuncTable*
	Generate() {	Generate() {
	return CFTGenerator<Pushback<std::deque<T, A> > >::Generate();	return CFTGenerator<Pushback<std::deque<T, A> > >::Generate();
	}	}


	};	};
	// Specialization for std::set	// Specialization for std::set
	template <class K, class T, class A> struct Proxy<std::set<K, T, A> > {	template <class K, class T, class A> struct Proxy<std::set<K, T, A> > {
	static CollFuncTable*	static CollFuncTable*
	Generate() {	Generate() {
	return CFTGenerator<Insert<std::set<K, T, A> > >::Generate();	return CFTGenerator<Insert<std::set<K, T, A> > >::Generate();
	}	}


	};	};
	// Specialization for std::multiset	// Specialization for std::multiset
	template <class K, class T, class A> struct Proxy<std::multiset<K, T, A> >	template <class K, class T, class A> struct Proxy<std::multiset<K, T, A>
	{	> {
	static CollFuncTable*	static CollFuncTable*
	Generate() {	Generate() {
	return CFTGenerator<Insert<std::multiset<K, T, A> > >::Generate();	return CFTGenerator<Insert<std::multiset<K, T, A> > >::Generate();
	}	}


	};	};
	// Specialization for std::map	// Specialization for std::map
	template <class K, class T, class R, class A> struct Proxy<std::map<K, T, R	template <class K, class T, class R, class A> struct Proxy<std::map<K, T
	, A> > {	, R, A> > {
	static CollFuncTable*	static CollFuncTable*
	Generate() {	Generate() {
	return CFTGenerator<MapInsert<std::map<K, T, R, A> > >::Generate();	return CFTGenerator<MapInsert<std::map<K, T, R, A> > >::Generate()
	}	;
		}


	};	};
	// Specialization for std::multimap	// Specialization for std::multimap
	template <class K, class T, class R, class A> struct Proxy<std::multimap<K,	template <class K, class T, class R, class A> struct Proxy<std::multimap
	T, R, A> > {	<K, T, R, A> > {
	static CollFuncTable*	static CollFuncTable*
	Generate() {	Generate() {
	return CFTGenerator<MapInsert<std::multimap<K, T, R, A> > >::Generate	return CFTGenerator<MapInsert<std::multimap<K, T, R, A> > >::Gener
	();	ate();
	}	}


	};	};
	// Specialization for std::queue -- not implemented	// Specialization for std::queue -- not implemented
	template <class K, class T> struct Proxy<std::queue<K, T> > {	template <class K, class T> struct Proxy<std::queue<K, T> > {
	static CollFuncTable*	static CollFuncTable*
	Generate() { return CFTNullGenerator::Generate(); }	Generate() { return CFTNullGenerator::Generate(); }

	};	};
	// Specialization for std::stack -- not implemented	// Specialization for std::stack -- not implemented
	template <class K, class T> struct Proxy<std::stack<K, T> > {	template <class K, class T> struct Proxy<std::stack<K, T> > {
	static CollFuncTable*	static CollFuncTable*
	Generate() { return CFTNullGenerator::Generate(); }	Generate() { return CFTNullGenerator::Generate(); }


	};	};
	#if defined(__GNUC__)	#if defined(__GNUC__)

	// Specialization for __gnu_cxx::hash_set	// Specialization for __gnu_cxx::hash_set
	template <class T, class F, class E, class A> struct Proxy<__gnu_cxx::hash_	template <class T, class F, class E, class A> struct Proxy<__gnu_cxx::ha
	set<T, F, E, A> > {	sh_set<T, F, E, A> > {
	static CollFuncTable*	static CollFuncTable*
	Generate() {	Generate() {
	return CFTGenerator<Insert<__gnu_cxx::hash_set<T, F, E, A> > >::Gener	return CFTGenerator<Insert<__gnu_cxx::hash_set<T, F, E, A> > >::Ge
	ate();	nerate();
	}	}


	};	};
	// Specialization for __gnu_cxx::hash_multiset	// Specialization for __gnu_cxx::hash_multiset
	template <class T, class F, class E, class A> struct Proxy<__gnu_cxx::hash_	template <class T, class F, class E, class A> struct Proxy<__gnu_cxx::ha
	multiset<T, F, E, A> > {	sh_multiset<T, F, E, A> > {
	static CollFuncTable*	static CollFuncTable*
	Generate() {	Generate() {
	return CFTGenerator<Insert<__gnu_cxx::hash_multiset<T, F, E, A> > >::	return CFTGenerator<Insert<__gnu_cxx::hash_multiset<T, F, E, A> >
	Generate();	>::Generate();
	}	}


	};	};
	// Specialization for __gnu_cxx::hash_map	// Specialization for __gnu_cxx::hash_map
	template <class K, class T, class F, class E, class A> struct Proxy<__gnu_c	template <class K, class T, class F, class E, class A> struct Proxy<__gn
	xx::hash_map<K, T, F, E, A> > {	u_cxx::hash_map<K, T, F, E, A> > {
	static CollFuncTable*	static CollFuncTable*
	Generate() {	Generate() {
	return CFTGenerator<MapInsert<__gnu_cxx::hash_map<K, T, F, E, A> > >:	return CFTGenerator<MapInsert<__gnu_cxx::hash_map<K, T, F, E, A> >
	:Generate();	>::Generate();
	}	}


	};	};
	// Specialization for __gnu_cxx::hash_multimap	// Specialization for __gnu_cxx::hash_multimap
	template <class K, class T, class F, class E, class A> struct Proxy<__gnu_c	template <class K, class T, class F, class E, class A> struct Proxy<__gn
	xx::hash_multimap<K, T, F, E, A> > {	u_cxx::hash_multimap<K, T, F, E, A> > {
	static CollFuncTable*	static CollFuncTable*
	Generate() {	Generate() {
	return CFTGenerator<MapInsert<__gnu_cxx::hash_multimap<K, T, F, E, A>	return CFTGenerator<MapInsert<__gnu_cxx::hash_multimap<K, T, F, E,
	> >::Generate();	A> > >::Generate();
	}	}


	};	};
	#elif defined(_WIN32)	#elif defined(_WIN32)

	// Specialization for stdext::hash_multiset	// Specialization for stdext::hash_multiset
	template <class K, class T, class A> struct Proxy<stdext::hash_multiset<K,	template <class K, class T, class A> struct Proxy<stdext::hash_multiset<
	T, A> > {	K, T, A> > {
	static CollFuncTable*	static CollFuncTable*
	Generate() {	Generate() {
	return CFTGenerator<Insert<stdext::hash_multiset<K, T, A> > >::Genera	return CFTGenerator<Insert<stdext::hash_multiset<K, T, A> > >::Gen
	te();	erate();
	}	}


	};	};
	// Specialization for stdext::hash_set	// Specialization for stdext::hash_set
	template <class K, class T, class A> struct Proxy<stdext::hash_set<K, T, A>	template <class K, class T, class A> struct Proxy<stdext::hash_set<K, T,
	> {	A> > {
	static CollFuncTable*	static CollFuncTable*
	Generate() {	Generate() {
	return CFTGenerator<Insert<stdext::hash_set<K, T, A> > >::Generate();	return CFTGenerator<Insert<stdext::hash_set<K, T, A> > >::Generate
	}	();
		}


	};	};
	// Specialization for stdext::hash_map	// Specialization for stdext::hash_map
	template <class K, class T, class R, class A> struct Proxy<stdext::hash_map	template <class K, class T, class R, class A> struct Proxy<stdext::hash_
	<K, T, R, A> > {	map<K, T, R, A> > {
	static CollFuncTable*	static CollFuncTable*
	Generate() {	Generate() {
	return CFTGenerator<MapInsert<stdext::hash_map<K, T, R, A> > >::Gener	return CFTGenerator<MapInsert<stdext::hash_map<K, T, R, A> > >::Ge
	ate();	nerate();
	}	}


	};	};
	// Specialization for stdext::hash_multimap	// Specialization for stdext::hash_multimap
	template <class K, class T, class R, class A> struct Proxy<stdext::hash_mul	template <class K, class T, class R, class A> struct Proxy<stdext::hash_
	timap<K, T, R, A> > {	multimap<K, T, R, A> > {
	static CollFuncTable*	static CollFuncTable*
	Generate() {	Generate() {
	return CFTGenerator<MapInsert<stdext::hash_multimap<K, T, R, A> > >::	return CFTGenerator<MapInsert<stdext::hash_multimap<K, T, R, A> >
	Generate();	>::Generate();
	}	}


	};	};
	#endif	#endif


	// Specialization for std::bitset	// Specialization for std::bitset
	template <typename B> struct StdBitSetHelper {};	template <typename B> struct StdBitSetHelper {};

	#ifndef __CINT__	#ifndef __CINT__

	template <typename Bitset_t> struct CollType<StdBitSetHelper<Bitset_t> > :	template <typename Bitset_t> struct CollType<StdBitSetHelper<Bitset_t> >
	public Address<const bool&> {	: public Address<const bool&> {
	typedef Bitset_t Cont_t;	typedef Bitset_t Cont_t;
	typedef std::pair<size_t, bool> Iter_t;	typedef std::pair<size_t, 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;

	virtual ~CollType() {}	virtual ~CollType() {}

	static inline PCont_t	static inline PCont_t
	object(void* ptr) {	object(void* ptr) {
	return PCont_t(PEnv_t(ptr)->fObject);	return PCont_t(PEnv_t(ptr)->fObject);
	}	}

	static void*
	size(void* env) {
	PEnv_t e = PEnv_t(env);
	e->fSize = PCont_t(e->fObject)->size();
	return &e->fSize;
	}

	static void*
	clear(void* env) {
	object(env)->reset();
	return 0;
	}

	static void*
	first(void* env) {
	PEnv_t e = PEnv_t(env);
	PCont_t c = PCont_t(e->fObject);
	e->fIterator.first = 0;
	e->fIterator.second = c->size() > 0 ? c->test(e->fIterator.first) : f
	alse; // Iterator actually hold the value.
	e->fSize = c->size();
	return 0;
	}


	static void*	static void*
	next(void* env) {	size(void* env) {
	PEnv_t e = PEnv_t(env);	PEnv_t e = PEnv_t(env);
	PCont_t c = PCont_t(e->fObject);	e->fSize = PCont_t(e->fObject)->size();
		return &e->fSize;
		}


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


	static void*	static void*
	construct(void*,size_t) {	first(void* env) {
	// Nothing to construct.	PEnv_t e = PEnv_t(env);
	return 0;	PCont_t c = PCont_t(e->fObject);
	}	e->fIterator.first = 0;
		e->fIterator.second = c->size() > 0 ? c->test(e->fIterator.first)
		: false; // Iterator actually hold the value.
		e->fSize = c->size();
		return 0;
		}


	static void*	static void*
	collect(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);
	PValue_t m = PValue_t(e->fStart); // 'start' is a buffer outside t
	he container.	for ( ; e->fIdx > 0 && e->fIterator.first != c->size(); ++(e->fIte
		rator.first), --e->fIdx) {}
		e->fIterator.second = (e->fIterator.first != c->size()) ? c->test(
		e->fIterator.first) : false;
		return 0;
		}


	for (size_t i = 0; i != c->size(); ++i, ++m) {	static void*
	*m = c->test(i);	construct(void*,size_t) {
		// Nothing to construct.
		return 0;
	}	}

	return 0;
	}


	static void	static void*
	destruct(void*,size_t) {	collect(void* coll, void *array) {
	// Nothing to destruct.	PCont_t c = PCont_t(coll);
	}	PValue_t m = PValue_t(array); // 'start' is a buffer outside th
		e container.

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


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


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

	static void resize(void* /obj/, size_t) { }

	static void*
	feed(void* env) {
	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) {	template <typename Bitset_t>
	c->set(i, *m);	struct Pushback<StdBitSetHelper<Bitset_t> > : public CollType<StdBitS
		etHelper<Bitset_t> > {
		typedef Bitset_t Cont_t;
		typedef bool Iter_t;
		typedef bool Value_t;
		typedef Environ<Iter_t> Env_t;
		typedef Env_t* PEnv_t;
		typedef Cont_t* PCont_t;
		typedef Value_t* PValue_t;

		static void resize(void* /obj/, size_t) { }

		static void*
		feed(void* env) {
		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 '
		buffer' outside the container.

		for (size_t i = 0; i < e->fSize; ++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) {	static void*
	c->set(i, *m);	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;
	}	}

	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*
	Generate() {	Generate() {
	return CFTGenerator<Pushback<StdBitSetHelper<B> > >::Generate();	return CFTGenerator<Pushback<StdBitSetHelper<B> > >::Generate();
	}	}


	};	};
	}	}

	#endif // Reflex_CollectionProxy	#endif // Reflex_CollectionProxy

End of changes. 90 change blocks.
	586 lines changed or deleted	840 lines changed or added

	FTFace.h	FTFace.h

	skipping to change at line 44	skipping to change at line 44
	FTFace( const unsigned char *pBufferBytes, size_t bufferSizeInBytes );	FTFace( const unsigned char *pBufferBytes, size_t bufferSizeInBytes );

	/**	/**
	* Destructor	* Destructor
	*	*
	* Disposes of the current Freetype Face.	* Disposes of the current Freetype Face.
	*/	*/
	virtual ~FTFace();	virtual ~FTFace();

	/**	/**

	* Attach auxilliary file to font (e.g., font metrics).	* Attach auxiliary file to font (e.g., font metrics).
	*	*

	* @param fontFilePath auxilliary font file path.	* @param fontFilePath auxiliary font file path.
	* @return <code>true</code> if file has opened	* @return <code>true</code> if file has opened
	* successfully.	* successfully.
	*/	*/
	bool Attach( const char* fontFilePath);	bool Attach( const char* fontFilePath);

	/**	/**

	* Attach auxilliary data to font (e.g., font metrics) from memory	* Attach auxiliary data to font (e.g., font metrics) from memory
	*	*
	* @param pBufferBytes the in-memory buffer	* @param pBufferBytes the in-memory buffer
	* @param bufferSizeInBytes the length of the buffer in bytes	* @param bufferSizeInBytes the length of the buffer in bytes
	* @return <code>true</code> if file has opened	* @return <code>true</code> if file has opened
	* successfully.	* successfully.
	*/	*/
	bool Attach( const unsigned char *pBufferBytes, size_t bufferSizeIn Bytes);	bool Attach( const unsigned char *pBufferBytes, size_t bufferSizeIn Bytes);

	/**	/**
	* Get the freetype face object..	* Get the freetype face object..

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

	FTFont.h	FTFont.h

	skipping to change at line 57	skipping to change at line 57
	* @param bufferSizeInBytes the length of the buffer in bytes	* @param bufferSizeInBytes the length of the buffer in bytes
	*/	*/
	FTFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes );	FTFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes );

	/**	/**
	* Destructor	* Destructor
	*/	*/
	virtual ~FTFont();	virtual ~FTFont();

	/**	/**

	* Attach auxilliary file to font e.g font metrics.	* Attach auxiliary file to font e.g font metrics.
	*	*
	* Note: not all font formats implement this function.	* Note: not all font formats implement this function.
	*	*

	* @param fontFilePath auxilliary font file path.	* @param fontFilePath auxiliary font file path.
	* @return <code>true</code> if file has been attached	* @return <code>true</code> if file has been attached
	* successfully.	* successfully.
	*/	*/
	bool Attach( const char* fontFilePath);	bool Attach( const char* fontFilePath);

	/**	/**

	* Attach auxilliary data to font e.g font metrics, from memory	* Attach auxiliary data to font e.g font metrics, from memory
	*	*
	* Note: not all font formats implement this function.	* Note: not all font formats implement this function.
	*	*
	* @param pBufferBytes the in-memory buffer	* @param pBufferBytes the in-memory buffer
	* @param bufferSizeInBytes the length of the buffer in bytes	* @param bufferSizeInBytes the length of the buffer in bytes
	* @return <code>true</code> if file has been attached	* @return <code>true</code> if file has been attached
	* successfully.	* successfully.
	*/	*/
	bool Attach( const unsigned char *pBufferBytes, size_t bufferSizeIn Bytes);	bool Attach( const unsigned char *pBufferBytes, size_t bufferSizeIn Bytes);


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

	Factory.h	Factory.h

	// @(#)root/mathcore:$Id: Factory.h 37448 2010-12-09 20:20:56Z moneta $	// @(#)root/tmva $Id: Factory.h 40005 2011-06-27 15:29:10Z stelzer $
	// Author: L. Moneta Fri Dec 22 14:43:33 2006	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss, Ka
		i Voss, Eckhard von Toerne, Jan Therhaag


	/**********************************************************************	/**************************************************************************
	* *	********
	* 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
		*
		* Jan Therhaag <Jan.Therhaag@cern.ch> - U of Bonn, Germany
		*
		* Eckhard v. Toerne <evt@uni-bonn.de> - U of Bonn, Germany
		*
		* Helge Voss <Helge.Voss@cern.ch> - MPI-K Heidelberg, German
		y *
		* Kai Voss <Kai.Voss@cern.ch> - U. of Victoria, Canada
		*
		*
		*
		* Copyright (c) 2005-2011:
		*
		* CERN, Switzerland
		*
		* U. of Victoria, Canada
		*
		* MPI-K Heidelberg, Germany
		*
		* U. of Bonn, 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
	If no name is given use default values defined in MinimizerOptions
	*/
	static ROOT::Math::Minimizer * CreateMinimizer(const std::string & minim
	izerType = "", const std::string & algoType = "");

	/**
	static method to create the distribution sampler class given a string
	specifying the type
	Supported sampler types are:
	Unuran, Foam
	If no name is given use default values defined in DistSamplerOptions
	*/
	static ROOT::Math::DistSampler * CreateDistSampler(const std::string & s
	amplerType ="");

	};


	} // 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.
	53 lines changed or deleted	360 lines changed or added

	Functions.h	Functions.h

	// @(#)root/smatrix:$Id: Functions.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/smatrix:$Id: Functions.h 48991 2013-03-28 15:25:11Z rdm $
	// Authors: T. Glebe, L. Moneta 2005	// Authors: T. Glebe, L. Moneta 2005

	#ifndef ROOT_Math_Functions	#ifndef ROOT_Math_Functions
	#define ROOT_Math_Functions	#define ROOT_Math_Functions
	// ********************************************************************	// ********************************************************************
	//	//
	// source:	// source:
	//	//
	// type: source code	// type: source code
	//	//

	skipping to change at line 360	skipping to change at line 360
	inline SVector<T,3> Cross(const VecExpr<A,T,3>& lhs, const VecExpr<B,T,3>& rhs) {	inline SVector<T,3> Cross(const VecExpr<A,T,3>& lhs, const VecExpr<B,T,3>& rhs) {
	return SVector<T,3>(lhs.apply(1)*rhs.apply(2) -	return SVector<T,3>(lhs.apply(1)*rhs.apply(2) -
	lhs.apply(2)*rhs.apply(1),	lhs.apply(2)*rhs.apply(1),
	lhs.apply(2)*rhs.apply(0) -	lhs.apply(2)*rhs.apply(0) -
	lhs.apply(0)*rhs.apply(2),	lhs.apply(0)*rhs.apply(2),
	lhs.apply(0)*rhs.apply(1) -	lhs.apply(0)*rhs.apply(1) -
	lhs.apply(1)*rhs.apply(0));	lhs.apply(1)*rhs.apply(0));
	}	}

	/** Unit.	/** Unit.

	Return a vector of unit lenght: \f$ \vec{e}_v = \vec{v}/\|\vec{v}\| \f$.	Return a vector of unit length: \f$ \vec{e}_v = \vec{v}/\|\vec{v}\| \f$.

	@ingroup VectFunction	@ingroup VectFunction
	@author T. Glebe	@author T. Glebe
	*/	*/
	//========================================================================= =====	//========================================================================= =====
	// unit: returns a unit vector	// unit: returns a unit vector
	//========================================================================= =====	//========================================================================= =====
	template <class T, unsigned int D>	template <class T, unsigned int D>
	inline SVector<T,D> Unit(const SVector<T,D>& rhs) {	inline SVector<T,D> Unit(const SVector<T,D>& rhs) {
	return SVector<T,D>(rhs).Unit();	return SVector<T,D>(rhs).Unit();

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

	HLFactory.h	HLFactory.h

	// @(#)root/roostats:$Id: HLFactory.h 39391 2011-05-26 09:51:59Z moneta $	// @(#)root/roostats:$Id: HLFactory.h 48991 2013-03-28 15:25:11Z rdm $

	/*************************************************************************	/*************************************************************************
	* 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 98	skipping to change at line 98

	/// The datasets combination	/// The datasets combination
	RooDataSet* fComboDataset;	RooDataSet* fComboDataset;

	/// Flag to keep trace of the status of the combination	/// Flag to keep trace of the status of the combination
	bool fCombinationDone;	bool fCombinationDone;

	/// Create the category for the combinations	/// Create the category for the combinations
	void fCreateCategory();	void fCreateCategory();


	/// Check the lenght of the lists	/// Check the length of the lists
	bool fNamesListsConsistent();	bool fNamesListsConsistent();

	/// List of channels names to combine for the signal plus background pd fs	/// List of channels names to combine for the signal plus background pd fs
	TList fSigBkgPdfNames;	TList fSigBkgPdfNames;

	/// List of channels names to combine for the background pdfs	/// List of channels names to combine for the background pdfs
	TList fBkgPdfNames;	TList fBkgPdfNames;

	/// List of channels names to combine for the datasets	/// List of channels names to combine for the datasets
	TList fDatasetsNames;	TList fDatasetsNames;

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

	Interval.h	Interval.h

	// @(#)root/tmva $Id: Interval.h 40005 2011-06-27 15:29:10Z stelzer $	// @(#)root/tmva $Id: Interval.h 48991 2013-03-28 15:25:11Z rdm $
	// 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 34	skipping to change at line 34

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

	/////////////////////////////////////////////////////////////////////////// ///	/////////////////////////////////////////////////////////////////////////// ///
	// //	// //
	// Interval //	// Interval //
	// //	// //
	// Interval definition, continuous and discrete //	// Interval definition, continuous and discrete //
	// //	// //

	// Interval(min,max) : a continous interval [min,max] //	// Interval(min,max) : a continuous interval [min,max] //
	// Interval(min,max,n): a "discrete interval" [min,max], i.e the n numbers: //	// 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 //	// min, min+step, min+2step,...., min+(n-1)step, min+n*step=max //
	// e.g.: Interval(1,5,5)=1,2,3,4,5 //	// e.g.: Interval(1,5,5)=1,2,3,4,5 //
	// Interval(.5,1.,6)= .5, .6., .7, .8, .9, 1.0 //	// Interval(.5,1.,6)= .5, .6., .7, .8, .9, 1.0 //
	// //	// //
	// Note: bin counting starts from ZERO unlike in ROOT histograms //	// Note: bin counting starts from ZERO unlike in ROOT histograms //
	// //	// //
	// Example: Interval(.5,1.,6) //	// Example: Interval(.5,1.,6) //
	// //	// //
	// [ min max ] //	// [ min max ] //

	skipping to change at line 92	skipping to change at line 92
	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
	MsgLogger& Log() const { return *fgLogger; }	MsgLogger& Log() const { return *fgLogger; }


	ClassDef(Interval,0) // Interval definition, continous and discret e	ClassDef(Interval,0) // Interval definition, continuous and discre te
	};	};

	} // namespace TMVA	} // namespace TMVA

	#endif	#endif

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

	ProfileLikelihoodTestStat.h	ProfileLikelihoodTestStat.h

	// @(#)root/roostats:$Id: ProfileLikelihoodTestStat.h 46082 2012-09-20 13:5 5:31Z moneta $	// @(#)root/roostats:$Id: ProfileLikelihoodTestStat.h 49272 2013-04-18 19:1 0:58Z wouter $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	// Additional Contributions: Giovanni Petrucciani	// Additional Contributions: Giovanni Petrucciani
	/*************************************************************************	/*************************************************************************
	* 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 70	skipping to change at line 70
	// Proof constructor. Do not use.	// Proof constructor. Do not use.
	fPdf = 0;	fPdf = 0;
	fNll = 0;	fNll = 0;
	fCachedBestFitParams = 0;	fCachedBestFitParams = 0;
	fLastData = 0;	fLastData = 0;
	fLimitType = twoSided;	fLimitType = twoSided;
	fSigned = false;	fSigned = false;
	fDetailedOutputWithErrorsAndPulls = false;	fDetailedOutputWithErrorsAndPulls = false;
	fDetailedOutputEnabled = false;	fDetailedOutputEnabled = false;
	fDetailedOutput = NULL;	fDetailedOutput = NULL;

		fLOffset = kFALSE ;

	fVarName = "Profile Likelihood Ratio";	fVarName = "Profile Likelihood Ratio";
	fReuseNll = false;	fReuseNll = false;
	fMinimizer=::ROOT::Math::MinimizerOptions::DefaultMinimizerType().c_ str();	fMinimizer=::ROOT::Math::MinimizerOptions::DefaultMinimizerType().c_ str();
	fStrategy=::ROOT::Math::MinimizerOptions::DefaultStrategy();	fStrategy=::ROOT::Math::MinimizerOptions::DefaultStrategy();
	fTolerance=TMath::Max(1.,::ROOT::Math::MinimizerOptions::DefaultTol erance());	fTolerance=TMath::Max(1.,::ROOT::Math::MinimizerOptions::DefaultTol erance());
	fPrintLevel=::ROOT::Math::MinimizerOptions::DefaultPrintLevel();	fPrintLevel=::ROOT::Math::MinimizerOptions::DefaultPrintLevel();

	}	}
	ProfileLikelihoodTestStat(RooAbsPdf& pdf) {	ProfileLikelihoodTestStat(RooAbsPdf& pdf) {
	fPdf = &pdf;	fPdf = &pdf;
	fNll = 0;	fNll = 0;
	fCachedBestFitParams = 0;	fCachedBestFitParams = 0;
	fLastData = 0;	fLastData = 0;
	fLimitType = twoSided;	fLimitType = twoSided;
	fSigned = false;	fSigned = false;
	fDetailedOutputWithErrorsAndPulls = false;	fDetailedOutputWithErrorsAndPulls = false;
	fDetailedOutputEnabled = false;	fDetailedOutputEnabled = false;
	fDetailedOutput = NULL;	fDetailedOutput = NULL;

		fLOffset = kFALSE ;

	fVarName = "Profile Likelihood Ratio";	fVarName = "Profile Likelihood Ratio";
	fReuseNll = false;	fReuseNll = false;
	fMinimizer=::ROOT::Math::MinimizerOptions::DefaultMinimizerType().c_ str();	fMinimizer=::ROOT::Math::MinimizerOptions::DefaultMinimizerType().c_ str();
	fStrategy=::ROOT::Math::MinimizerOptions::DefaultStrategy();	fStrategy=::ROOT::Math::MinimizerOptions::DefaultStrategy();
	// avoid default tolerance to be too small (1. is default in RooMini mizer)	// avoid default tolerance to be too small (1. is default in RooMini mizer)
	fTolerance=TMath::Max(1.,::ROOT::Math::MinimizerOptions::DefaultTole rance());	fTolerance=TMath::Max(1.,::ROOT::Math::MinimizerOptions::DefaultTole rance());
	fPrintLevel=::ROOT::Math::MinimizerOptions::DefaultPrintLevel();	fPrintLevel=::ROOT::Math::MinimizerOptions::DefaultPrintLevel();
	}	}
	virtual ~ProfileLikelihoodTestStat() {	virtual ~ProfileLikelihoodTestStat() {

	skipping to change at line 117	skipping to change at line 119
	void SetOneSidedDiscovery(Bool_t flag=true) {fLimitType = (flag ? oneS idedDiscovery : twoSided);}	void SetOneSidedDiscovery(Bool_t flag=true) {fLimitType = (flag ? oneS idedDiscovery : twoSided);}
	void SetSigned(Bool_t flag=true) {fSigned = flag;} // +/- t_mu instea d of t_mu>0 with one-sided settings	void SetSigned(Bool_t flag=true) {fSigned = flag;} // +/- t_mu instea d of t_mu>0 with one-sided settings
	//void SetOneSidedDiscovery(Bool_t flag=true) {fOneSidedDiscovery = fl ag;}	//void SetOneSidedDiscovery(Bool_t flag=true) {fOneSidedDiscovery = fl ag;}

	bool IsTwoSided() const { return fLimitType == twoSided; }	bool IsTwoSided() const { return fLimitType == twoSided; }
	bool IsOneSidedDiscovery() const { return fLimitType == oneSidedDiscov ery; }	bool IsOneSidedDiscovery() const { return fLimitType == oneSidedDiscov ery; }

	static void SetAlwaysReuseNLL(Bool_t flag);	static void SetAlwaysReuseNLL(Bool_t flag);

	void SetReuseNLL(Bool_t flag) { fReuseNll = flag ; }	void SetReuseNLL(Bool_t flag) { fReuseNll = flag ; }

		void SetLOffset(Bool_t flag=kTRUE) { fLOffset = flag ; }

	void SetMinimizer(const char* minimizer){ fMinimizer=minimizer;}	void SetMinimizer(const char* minimizer){ fMinimizer=minimizer;}
	void SetStrategy(Int_t strategy){fStrategy=strategy;}	void SetStrategy(Int_t strategy){fStrategy=strategy;}
	void SetTolerance(double tol){fTolerance=tol;}	void SetTolerance(double tol){fTolerance=tol;}
	void SetPrintLevel(Int_t printlevel){fPrintLevel=printlevel;}	void SetPrintLevel(Int_t printlevel){fPrintLevel=printlevel;}

	// 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) {
	return EvaluateProfileLikelihood(0, data, paramsOfInterest);	return EvaluateProfileLikelihood(0, data, paramsOfInterest);
	}	}

	skipping to change at line 187	skipping to change at line 190
	RooArgSet fConditionalObs; // conditional observables	RooArgSet fConditionalObs; // conditional observables

	TString fVarName;	TString fVarName;

	static Bool_t fgAlwaysReuseNll ;	static Bool_t fgAlwaysReuseNll ;
	Bool_t fReuseNll ;	Bool_t fReuseNll ;
	TString fMinimizer;	TString fMinimizer;
	Int_t fStrategy;	Int_t fStrategy;
	Double_t fTolerance;	Double_t fTolerance;
	Int_t fPrintLevel;	Int_t fPrintLevel;

		Bool_t fLOffset ;

	protected:	protected:


	ClassDef(ProfileLikelihoodTestStat,8) // implements the profile lik elihood ratio as a test statistic to be used with several tools	ClassDef(ProfileLikelihoodTestStat,9) // implements the profile lik elihood ratio as a test statistic to be used with several tools
	};	};
	}	}

	#endif	#endif

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

	RVersion.h	RVersion.h

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


	#define ROOT_RELEASE "5.34/05"	#define ROOT_RELEASE "5.34/06"
	#define ROOT_RELEASE_DATE "Feb 14 2013"	#define ROOT_RELEASE_DATE "Apr 19 2013"
	#define ROOT_RELEASE_TIME "22:45:52"	#define ROOT_RELEASE_TIME "12:41:19"
	#define ROOT_SVN_REVISION 48568	#define ROOT_SVN_REVISION 49274
	#define ROOT_SVN_BRANCH "branches/v5-34-00-patches"	#define ROOT_SVN_BRANCH "branches/v5-34-00-patches"

	#define ROOT_VERSION_CODE 336389	#define ROOT_VERSION_CODE 336390
	#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

	RooAbsArg.h	RooAbsArg.h

	skipping to change at line 53	skipping to change at line 53
	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 RooWorkspace ;
	class RooRealProxy ;	class RooRealProxy ;
	/* class TGraphStruct ; */	/* class TGraphStruct ; */


		class RooRefArray : public TObjArray {
		public:
		RooRefArray() : TObjArray() {
		} ;
		RooRefArray(const RooRefArray& other) : TObjArray(other) {
		}
		virtual ~RooRefArray() {} ;
		protected:
		ClassDef(RooRefArray,1) // Helper class for proxy lists
		} ;

	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 {

	skipping to change at line 253	skipping to change at line 264
	// Accessors to transient attributes	// Accessors to transient attributes
	void setTransientAttribute(const Text_t* name, Bool_t value=kTRUE) ;	void setTransientAttribute(const Text_t* name, Bool_t value=kTRUE) ;
	Bool_t getTransientAttribute(const Text_t* name) const ;	Bool_t getTransientAttribute(const Text_t* name) const ;
	inline const std::set<std::string>& transientAttributes() const {	inline const std::set<std::string>& transientAttributes() const {
	// Return set of transient boolean attributes	// Return set of transient boolean attributes
	return _boolAttribTransient ;	return _boolAttribTransient ;
	}	}

	inline Bool_t isConstant() const {	inline Bool_t isConstant() const {
	// Returns true if 'Constant' attribute is set	// Returns true if 'Constant' attribute is set

	return getAttribute("Constant") ;	return _isConstant ; //getAttribute("Constant") ;
	}	}
	RooLinkedList getCloningAncestors() const ;	RooLinkedList getCloningAncestors() const ;

	// Sorting	// Sorting
	Int_t Compare(const TObject* other) const ;	Int_t Compare(const TObject* other) const ;
	virtual Bool_t IsSortable() const {	virtual Bool_t IsSortable() const {
	// Object is sortable in ROOT container class	// Object is sortable in ROOT container class
	return kTRUE ;	return kTRUE ;
	}	}

	//Debug hooks	//Debug hooks
	static void verboseDirty(Bool_t flag) ;	static void verboseDirty(Bool_t flag) ;
	void printDirty(Bool_t depth=kTRUE) const ;	void printDirty(Bool_t depth=kTRUE) const ;

	static void setDirtyInhibit(Bool_t flag) ;	static void setDirtyInhibit(Bool_t flag) ;

	virtual Bool_t operator==(const RooAbsArg& other) = 0 ;	virtual Bool_t operator==(const RooAbsArg& other) = 0 ;

		virtual Bool_t isIdentical(const RooAbsArg& other, Bool_t assumeSameType= kFALSE) = 0 ;

	// Range management	// Range management
	virtual Bool_t inRange(const char*) const {	virtual Bool_t inRange(const char*) const {
	// Is value in range (dummy interface always returns true)	// Is value in range (dummy interface always returns true)
	return kTRUE ;	return kTRUE ;
	}	}
	virtual Bool_t hasRange(const char*) const {	virtual Bool_t hasRange(const char*) const {
	// Has this argument a defined range (dummy interface always returns fl ase)	// Has this argument a defined range (dummy interface always returns fl ase)
	return kFALSE ;	return kFALSE ;
	}	}

	skipping to change at line 444	skipping to change at line 456

	// Client-Server relatation and Proxy management	// Client-Server relatation and Proxy management
	friend class RooArgSet ;	friend class RooArgSet ;
	friend class RooAbsCollection ;	friend class RooAbsCollection ;
	friend class RooCustomizer ;	friend class RooCustomizer ;
	friend class RooWorkspace ;	friend class RooWorkspace ;
	RooRefCountList _serverList ; // list of server objects	RooRefCountList _serverList ; // list of server objects
	RooRefCountList _clientList ; // list of client objects	RooRefCountList _clientList ; // list of client objects
	RooRefCountList _clientListShape ; // subset of clients that requested s hape dirty flag propagation	RooRefCountList _clientListShape ; // subset of clients that requested s hape dirty flag propagation
	RooRefCountList _clientListValue ; // subset of clients that requested v alue dirty flag propagation	RooRefCountList _clientListValue ; // subset of clients that requested v alue dirty flag propagation

	TRefArray _proxyList ; // list of proxies	RooRefArray _proxyList ; // list of proxies
	std::deque<RooAbsCache*> _cacheList ; // list of caches	std::deque<RooAbsCache*> _cacheList ; // list of caches
	TIterator* _clientShapeIter ; //! Iterator over _clientListShape	TIterator* _clientShapeIter ; //! Iterator over _clientListShape
	TIterator* _clientValueIter ; //! Iterator over _clientListValue	TIterator* _clientValueIter ; //! Iterator over _clientListValue

	// Server redirection interface	// Server redirection interface
	public:	public:
	Bool_t redirectServers(const RooAbsCollection& newServerList, Bool_t must ReplaceAll=kFALSE, Bool_t nameChange=kFALSE, Bool_t isRecursionStep=kFALSE) ;	Bool_t redirectServers(const RooAbsCollection& newServerList, Bool_t must ReplaceAll=kFALSE, Bool_t nameChange=kFALSE, Bool_t isRecursionStep=kFALSE) ;
	Bool_t recursiveRedirectServers(const RooAbsCollection& newServerList, Bo ol_t mustReplaceAll=kFALSE, Bool_t nameChange=kFALSE, Bool_t recurseInNewSe t=kTRUE) ;	Bool_t recursiveRedirectServers(const RooAbsCollection& newServerList, Bo ol_t mustReplaceAll=kFALSE, Bool_t nameChange=kFALSE, Bool_t recurseInNewSe t=kTRUE) ;
	virtual Bool_t redirectServersHook(const RooAbsCollection& /newServerLis t/, Bool_t /mustReplaceAll/, Bool_t /nameChange/, Bool_t /isRecursive /) { return kFALSE ; } ;	virtual Bool_t redirectServersHook(const RooAbsCollection& /newServerLis t/, Bool_t /mustReplaceAll/, Bool_t /nameChange/, Bool_t /isRecursive /) { return kFALSE ; } ;
	virtual void serverNameChangeHook(const RooAbsArg* /oldServer/, const R ooAbsArg* /newServer/) { } ;	virtual void serverNameChangeHook(const RooAbsArg* /oldServer/, const R ooAbsArg* /newServer/) { } ;

	skipping to change at line 542	skipping to change at line 554
	mutable Bool_t _fast ; // Allow fast access mode in getVal() and proxies	mutable Bool_t _fast ; // Allow fast access mode in getVal() and proxies

	// Owned components	// Owned components
	RooArgSet* _ownedComponents ; //! Set of owned component	RooArgSet* _ownedComponents ; //! Set of owned component

	mutable Bool_t _prohibitServerRedirect ; //! Prohibit server redirects -- Debugging tool	mutable Bool_t _prohibitServerRedirect ; //! Prohibit server redirects -- Debugging tool

	mutable RooExpensiveObjectCache* _eocache ; // Pointer to global cache ma nager for any expensive components created by this object	mutable RooExpensiveObjectCache* _eocache ; // Pointer to global cache ma nager for any expensive components created by this object

	mutable TNamed* _namePtr ; //! Do not persist. Pointer to global instance of string that matches object named	mutable TNamed* _namePtr ; //! Do not persist. Pointer to global instance of string that matches object named

		Bool_t _isConstant ; //! Cached isConstant status

		public:
		virtual void ioStreamerPass2() ;
		static void ioStreamerPass2Finalize() ;
		static std::map<RooAbsArg,TRefArray> _ioEvoList ; // temporary holding
		list for proxies needed in schema evolution


	ClassDef(RooAbsArg,5) // Abstract variable	ClassDef(RooAbsArg,6) // Abstract variable
	};	};

	std::ostream& operator<<(std::ostream& os, const RooAbsArg &arg);	std::ostream& operator<<(std::ostream& os, const RooAbsArg &arg);
	std::istream& operator>>(std::istream& is, RooAbsArg &arg) ;	std::istream& operator>>(std::istream& is, RooAbsArg &arg) ;

	#endif	#endif

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

	RooAbsOptTestStatistic.h	RooAbsOptTestStatistic.h

	skipping to change at line 36	skipping to change at line 36
	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() ;
	RooAbsOptTestStatistic(const char name, const char title, RooAbsReal& r eal, RooAbsData& data,	RooAbsOptTestStatistic(const char name, const char title, RooAbsReal& r eal, RooAbsData& data,
	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, RooFit::MPSplit interleave=RooFit::Bu lkPartition, Bool_t verbose=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() ;	RooAbsData& data() ;

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

	RooAbsReal.h	RooAbsReal.h

	skipping to change at line 80	skipping to change at line 80
	#endif	#endif
	}	}
	inline Double_t getVal(const RooArgSet& set) const { return _fast ? _val ue : getValV(&set) ; }	inline Double_t getVal(const RooArgSet& set) const { return _fast ? _val ue : getValV(&set) ; }

	virtual Double_t getValV(const RooArgSet* set=0) const ;	virtual Double_t getValV(const RooArgSet* set=0) const ;

	Double_t getPropagatedError(const RooFitResult& fr) ;	Double_t getPropagatedError(const RooFitResult& fr) ;

	Bool_t operator==(Double_t value) const ;	Bool_t operator==(Double_t value) const ;
	virtual Bool_t operator==(const RooAbsArg& other) ;	virtual Bool_t operator==(const RooAbsArg& other) ;

		virtual Bool_t isIdentical(const RooAbsArg& other, Bool_t assumeSameType=
		kFALSE) ;

	inline const Text_t *getUnit() const {	inline const Text_t *getUnit() const {
	// Return string with unit description	// Return string with unit description
	return _unit.Data();	return _unit.Data();
	}	}
	inline void setUnit(const char *unit) {	inline void setUnit(const char *unit) {
	// Set unit description to given string	// Set unit description to given string
	_unit= unit;	_unit= unit;
	}	}
	TString getTitle(Bool_t appendUnit= kFALSE) const;	TString getTitle(Bool_t appendUnit= kFALSE) const;


	skipping to change at line 111	skipping to change at line 113
	virtual Bool_t forceAnalyticalInt(const RooAbsArg& /dep/) const {	virtual Bool_t forceAnalyticalInt(const RooAbsArg& /dep/) const {
	// Interface to force RooRealIntegral to offer given observable for int ernal integration	// Interface to force RooRealIntegral to offer given observable for int ernal integration
	// 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 ;
	}	}

		Bool_t getForceNumInt() const { return _forceNumInt ; }

	// Chi^2 fits to histograms	// Chi^2 fits to histograms
	virtual RooFitResult* chi2FitTo(RooDataHist& data, const RooCmdArg& arg1= RooCmdArg::none(), const RooCmdArg& arg2=RooCmdArg::none(),	virtual RooFitResult* chi2FitTo(RooDataHist& data, const RooCmdArg& arg1= RooCmdArg::none(), const RooCmdArg& arg2=RooCmdArg::none(),
	const RooCmdArg& arg3=RooCmdArg::none(), con st RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5=RooCmdArg::none (),	const RooCmdArg& arg3=RooCmdArg::none(), con st RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5=RooCmdArg::none (),
	const RooCmdArg& arg6=RooCmdArg::none(), con st RooCmdArg& arg7=RooCmdArg::none(), const 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, const RooCmdArg& arg1=R ooCmdArg::none(), const RooCmdArg& arg2=RooCmdArg::none(),	virtual RooAbsReal* createChi2(RooDataHist& data, const RooCmdArg& arg1=R ooCmdArg::none(), const RooCmdArg& arg2=RooCmdArg::none(),
	const RooCmdArg& arg3=RooCmdArg::none(), c onst RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5=RooCmdArg::no ne(),	const RooCmdArg& arg3=RooCmdArg::none(), c onst RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5=RooCmdArg::no ne(),

	skipping to change at line 383	skipping to change at line 386
	Double_t _plotMin ; // Minimum of plot range	Double_t _plotMin ; // Minimum of plot range
	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 Bool_t _boolValue ; //! Transient cache for bool values from tr ee 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 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


	skipping to change at line 404	skipping to change at line 408

	static Bool_t _cacheCheck ; // If true, always validate contents of clean which outcome of evaluate()	static Bool_t _cacheCheck ; // If true, always validate contents of clean which outcome of evaluate()

	friend class RooDataProjBinding ;	friend class RooDataProjBinding ;
	friend class RooAbsOptGoodnessOfFit ;	friend class RooAbsOptGoodnessOfFit ;

	struct PlotOpt {	struct PlotOpt {
	PlotOpt() : drawOptions("L"), scaleFactor(1.0), stype(Relative), projDat a(0), binProjData(kFALSE), projSet(0), precision(1e-3),	PlotOpt() : drawOptions("L"), scaleFactor(1.0), stype(Relative), projDat a(0), binProjData(kFALSE), projSet(0), precision(1e-3),
	shiftToZero(kFALSE),projDataSet(0),normRangeName(0),rangeLo( 0),rangeHi(0),postRangeFracScale(kFALSE),wmode(RooCurve::Extended),	shiftToZero(kFALSE),projDataSet(0),normRangeName(0),rangeLo( 0),rangeHi(0),postRangeFracScale(kFALSE),wmode(RooCurve::Extended),
	projectionRangeName(0),curveInvisible(kFALSE), curveName(0), addToCurveName(0),addToWgtSelf(1.),addToWgtOther(1.),	projectionRangeName(0),curveInvisible(kFALSE), curveName(0), addToCurveName(0),addToWgtSelf(1.),addToWgtOther(1.),

	numCPU(1),interleave(kTRUE),curveNameSuffix(""), numee(10), eeval(0), doeeval(kFALSE), progress(kFALSE) {} ;	numCPU(1),interleave(RooFit::Interleave),curveNameSuffix("") , numee(10), eeval(0), doeeval(kFALSE), progress(kFALSE) {} ;
	Option_t* drawOptions ;	Option_t* drawOptions ;
	Double_t scaleFactor ;	Double_t scaleFactor ;
	ScaleType stype ;	ScaleType stype ;
	const RooAbsData* projData ;	const RooAbsData* projData ;
	Bool_t binProjData ;	Bool_t binProjData ;
	const RooArgSet* projSet ;	const RooArgSet* projSet ;
	Double_t precision ;	Double_t precision ;
	Bool_t shiftToZero ;	Bool_t shiftToZero ;
	const RooArgSet* projDataSet ;	const RooArgSet* projDataSet ;
	const char* normRangeName ;	const char* normRangeName ;

	skipping to change at line 426	skipping to change at line 430
	Double_t rangeHi ;	Double_t rangeHi ;
	Bool_t postRangeFracScale ;	Bool_t postRangeFracScale ;
	RooCurve::WingMode wmode ;	RooCurve::WingMode wmode ;
	const char* projectionRangeName ;	const char* projectionRangeName ;
	Bool_t curveInvisible ;	Bool_t curveInvisible ;
	const char* curveName ;	const char* curveName ;
	const char* addToCurveName ;	const char* addToCurveName ;
	Double_t addToWgtSelf ;	Double_t addToWgtSelf ;
	Double_t addToWgtOther ;	Double_t addToWgtOther ;
	Int_t numCPU ;	Int_t numCPU ;

	Bool_t interleave ;	RooFit::MPSplit interleave ;
	const char* curveNameSuffix ;	const char* curveNameSuffix ;
	Int_t numee ;	Int_t numee ;
	Double_t eeval ;	Double_t eeval ;
	Bool_t doeeval ;	Bool_t doeeval ;
	Bool_t progress ;	Bool_t progress ;
	} ;	} ;

	// Plot implementation functions	// Plot implementation functions
	virtual RooPlot plotOn(RooPlot frame, PlotOpt o) const;	virtual RooPlot plotOn(RooPlot frame, PlotOpt o) const;
	virtual RooPlot plotAsymOn(RooPlot frame, const RooAbsCategoryLValue& a symCat, PlotOpt o) const;	virtual RooPlot plotAsymOn(RooPlot frame, const RooAbsCategoryLValue& a symCat, PlotOpt o) const;

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

	RooAbsTestStatistic.h	RooAbsTestStatistic.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_TEST_STATISTIC	#ifndef ROO_ABS_TEST_STATISTIC
	#define ROO_ABS_TEST_STATISTIC	#define ROO_ABS_TEST_STATISTIC

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

		#include "TStopwatch.h"
	#include <string>	#include <string>

	class RooArgSet ;	class RooArgSet ;
	class RooAbsData ;	class RooAbsData ;
	class RooAbsReal ;	class RooAbsReal ;
	class RooSimultaneous ;	class RooSimultaneous ;
	class RooRealMPFE ;	class RooRealMPFE ;

	class RooAbsTestStatistic ;	class RooAbsTestStatistic ;
	typedef RooAbsTestStatistic* pRooAbsTestStatistic ;	typedef RooAbsTestStatistic* pRooAbsTestStatistic ;
	typedef RooAbsData* pRooAbsData ;	typedef RooAbsData* pRooAbsData ;
	typedef RooRealMPFE* pRooRealMPFE ;	typedef RooRealMPFE* pRooRealMPFE ;

	class RooAbsTestStatistic : public RooAbsReal {	class RooAbsTestStatistic : public RooAbsReal {
	public:	public:

	// Constructors, assignment etc	// Constructors, assignment etc
	RooAbsTestStatistic() ;	RooAbsTestStatistic() ;
	RooAbsTestStatistic(const char name, const char title, RooAbsReal& real , RooAbsData& data,	RooAbsTestStatistic(const char name, const char title, RooAbsReal& real , RooAbsData& data,
	const RooArgSet& projDeps, const char* rangeName=0, co nst char* addCoefRangeName=0,	const RooArgSet& projDeps, const char* rangeName=0, co nst char* addCoefRangeName=0,

	Int_t nCPU=1, Bool_t interleave=kFALSE, Bool_t verbose =kTRUE, Bool_t splitCutRange=kTRUE) ;	Int_t nCPU=1, RooFit::MPSplit interleave=RooFit::BulkP artition, Bool_t verbose=kTRUE, Bool_t splitCutRange=kTRUE) ;
	RooAbsTestStatistic(const RooAbsTestStatistic& other, const char* name=0) ;	RooAbsTestStatistic(const RooAbsTestStatistic& other, const char* name=0) ;
	virtual ~RooAbsTestStatistic();	virtual ~RooAbsTestStatistic();
	virtual RooAbsTestStatistic* create(const char name, const char title, RooAbsReal& real, RooAbsData& data,	virtual RooAbsTestStatistic* create(const char name, const char title, RooAbsReal& real, RooAbsData& data,
	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 verbose=kTRUE, Bool_t splitCutRange=kFALSE) = 0 ;	Int_t nCPU=1, RooFit::MPSplit interlea ve=RooFit::BulkPartition, Bool_t verbose=kTRUE, Bool_t splitCutRange=kFALSE ) = 0 ;

	virtual void constOptimizeTestStatistic(ConstOpCode opcode, Bool_t doAlso TrackingOpt=kTRUE) ;	virtual void constOptimizeTestStatistic(ConstOpCode opcode, Bool_t doAlso TrackingOpt=kTRUE) ;

	virtual Double_t combinedValue(RooAbsReal** gofArray, Int_t nVal) const = 0 ;	virtual Double_t combinedValue(RooAbsReal** gofArray, Int_t nVal) const = 0 ;
	virtual Double_t globalNormalization() const {	virtual Double_t globalNormalization() const {
	// Default value of global normalization factor is 1.0	// Default value of global normalization factor is 1.0
	return 1.0 ;	return 1.0 ;
	}	}

	Bool_t setData(RooAbsData& data, Bool_t cloneData=kTRUE) ;	Bool_t setData(RooAbsData& data, Bool_t cloneData=kTRUE) ;

	skipping to change at line 127	skipping to change at line 128
	Bool_t initialize() ;	Bool_t initialize() ;
	void initSimMode(RooSimultaneous* pdf, RooAbsData* data, const RooArgSet* projDeps, const char* rangeName, const char* addCoefRangeName) ;	void initSimMode(RooSimultaneous* pdf, RooAbsData* data, const RooArgSet* projDeps, const char* rangeName, const char* addCoefRangeName) ;
	void initMPMode(RooAbsReal* real, RooAbsData* data, const RooArgSet* proj Deps, const char* rangeName, const char* addCoefRangeName) ;	void initMPMode(RooAbsReal* real, RooAbsData* data, const RooArgSet* proj Deps, const char* rangeName, const char* addCoefRangeName) ;

	mutable Bool_t _init ; //! Is object initialized	mutable Bool_t _init ; //! Is object initialized
	GOFOpMode _gofOpMode ; // Operation mode of test statistic insta nce	GOFOpMode _gofOpMode ; // Operation mode of test statistic insta nce

	Int_t _nEvents ; // Total number of events in test statist ic calculation	Int_t _nEvents ; // Total number of events in test statist ic calculation
	Int_t _setNum ; // Partition number of this instance in p arallel calculation mode	Int_t _setNum ; // Partition number of this instance in p arallel calculation mode
	Int_t _numSets ; // Total number of partitions in parallel calculation mode	Int_t _numSets ; // Total number of partitions in parallel calculation mode

		Int_t _extSet ; //! Number of designated set to calculate d extended term

	// Simultaneous mode data	// Simultaneous mode data
	Int_t _nGof ; // Number of sub-contexts	Int_t _nGof ; // Number of sub-contexts
	pRooAbsTestStatistic* _gofArray ; //! Array of sub-contexts representing part of the combined test statistic	pRooAbsTestStatistic* _gofArray ; //! Array of sub-contexts representing part of the combined test statistic

		std::vector<RooFit::MPSplit> _gofSplitMode ; //! GOF MP Split mode specif ied by component (when Auto is active)

	// Parallel mode data	// Parallel mode data
	Int_t _nCPU ; // Number of processors to use in parallel c alculation mode	Int_t _nCPU ; // Number of processors to use in parallel c alculation mode
	pRooRealMPFE* _mpfeArray ; //! Array of parallel execution frond ends	pRooRealMPFE* _mpfeArray ; //! Array of parallel execution frond ends


	Bool_t _mpinterl ; // Use interleaving strategy rather than N-wis e split for partioning of dataset for multiprocessor-split	RooFit::MPSplit _mpinterl ; // Use interleaving strategy rather th an N-wise split for partioning of dataset for multiprocessor-split
	Bool_t _doOffset ; // Apply interval value offset to control nume ric precision?	Bool_t _doOffset ; // Apply interval value offset to control nume ric precision?
	mutable Double_t _offset ; //! Offset	mutable Double_t _offset ; //! Offset

	ClassDef(RooAbsTestStatistic,2) // Abstract base class for real-valued te st statistics	ClassDef(RooAbsTestStatistic,2) // Abstract base class for real-valued te st statistics


	};	};

	#endif	#endif

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

	RooConstraintSum.h	RooConstraintSum.h
	/************************************************************************ *	/************************************************************************ *
	* Project: RooFit *	* Project: RooFit *
	* Package: RooFitCore *	* Package: RooFitCore *

	* File: $Id: RooConstraintSum.h 47307 2012-11-15 12:12:32Z wouter $	* File: $Id: RooConstraintSum.h 49228 2013-04-12 10:56:12Z 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) *
	************************************************************************ */	************************************************************************ */
	#ifndef ROO_CONSTRAINT_SUM	#ifndef ROO_CONSTRAINT_SUM
	#define ROO_CONSTRAINT_SUM	#define ROO_CONSTRAINT_SUM

	#include "RooAbsReal.h"	#include "RooAbsReal.h"
	#include "RooListProxy.h"	#include "RooListProxy.h"
	#include "RooSetProxy.h"	#include "RooSetProxy.h"

		#include "TStopwatch.h"

	class RooRealVar;	class RooRealVar;
	class RooArgList ;	class RooArgList ;

	class RooConstraintSum : public RooAbsReal {	class RooConstraintSum : public RooAbsReal {
	public:	public:

	RooConstraintSum() ;	RooConstraintSum() ;
	RooConstraintSum(const char name, const char title, const RooArgSet& co nstraintSet, const RooArgSet& paramSet) ;	RooConstraintSum(const char name, const char title, const RooArgSet& co nstraintSet, const RooArgSet& paramSet) ;
	virtual ~RooConstraintSum() ;	virtual ~RooConstraintSum() ;

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

	RooDataWeightedAverage.h	RooDataWeightedAverage.h
	/************************************************************************ *	/************************************************************************ *
	* Project: RooFit *	* Project: RooFit *
	* Package: RooFitCore *	* Package: RooFitCore *

	* File: $Id: RooDataWeightedAverage.h 30378 2009-09-23 13:42:12Z wouter $	* File: $Id: RooDataWeightedAverage.h 49228 2013-04-12 10:56:12Z 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 31	skipping to change at line 31

	class RooDataWeightedAverage : public RooAbsOptTestStatistic {	class RooDataWeightedAverage : public RooAbsOptTestStatistic {
	public:	public:

	// Constructors, assignment etc	// Constructors, assignment etc
	RooDataWeightedAverage() {	RooDataWeightedAverage() {
	// Default constructor	// Default constructor
	} ;	} ;

	RooDataWeightedAverage(const char name, const char title, RooAbsReal& r eal, RooAbsData& data, const RooArgSet& projDeps,	RooDataWeightedAverage(const char name, const char title, RooAbsReal& r eal, RooAbsData& data, const RooArgSet& projDeps,

	Int_t nCPU=1, Bool_t interleave=kFALSE, Bool_t show Progress=kFALSE, Bool_t verbose=kTRUE) ;	Int_t nCPU=1, RooFit::MPSplit interleave=RooFit::Bu lkPartition, Bool_t showProgress=kFALSE, Bool_t verbose=kTRUE) ;

	RooDataWeightedAverage(const RooDataWeightedAverage& other, const char* n ame=0);	RooDataWeightedAverage(const RooDataWeightedAverage& other, const char* n ame=0);
	virtual TObject* clone(const char* newname) const { return new RooDataWei ghtedAverage(*this,newname); }	virtual TObject* clone(const char* newname) const { return new RooDataWei ghtedAverage(*this,newname); }

	virtual RooAbsTestStatistic* create(const char name, const char title, RooAbsReal& real, RooAbsData& adata,	virtual RooAbsTestStatistic* create(const char name, const char title, RooAbsReal& real, RooAbsData& adata,
	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 verbose=kTRUE, Bool_t /splitCutRange/=kFALSE) {	Int_t nCPU=1, RooFit::MPSplit interlea ve=RooFit::BulkPartition, Bool_t verbose=kTRUE, Bool_t /splitCutRange/=kF ALSE) {
	// Virtual constructor	// Virtual constructor
	return new RooDataWeightedAverage(name,title,real,adata,projDeps,nCPU,i nterleave,verbose) ;	return new RooDataWeightedAverage(name,title,real,adata,projDeps,nCPU,i nterleave,verbose) ;
	}	}

	virtual Double_t globalNormalization() const ;	virtual Double_t globalNormalization() const ;

	virtual ~RooDataWeightedAverage();	virtual ~RooDataWeightedAverage();

	protected:	protected:


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

	RooGlobalFunc.h	RooGlobalFunc.h

	skipping to change at line 60	skipping to change at line 60
	class TF2 ;	class TF2 ;
	class TF3 ;	class TF3 ;
	class TTree ;	class TTree ;

	namespace RooFit {	namespace RooFit {

	enum MsgLevel { DEBUG=0, INFO=1, PROGRESS=2, WARNING=3, ERROR=4, FATAL=5 } ;	enum MsgLevel { DEBUG=0, INFO=1, PROGRESS=2, WARNING=3, ERROR=4, FATAL=5 } ;
	enum MsgTopic { Generation=1, Minimization=2, Plotting=4, Fitting=8, Integr ation=16, LinkStateMgmt=32,	enum MsgTopic { Generation=1, Minimization=2, Plotting=4, Fitting=8, Integr ation=16, LinkStateMgmt=32,
	Eval=64, Caching=128, Optimization=256, ObjectHandling=512, InputAr guments=1024, Tracing=2048,	Eval=64, Caching=128, Optimization=256, ObjectHandling=512, InputAr guments=1024, Tracing=2048,
	Contents=4096, DataHandling=8192, NumIntegration=16384 } ;	Contents=4096, DataHandling=8192, NumIntegration=16384 } ;

		enum MPSplit { BulkPartition=0, Interleave=1, SimComponents=2, Hybrid=3 } ;

	// RooAbsReal::plotOn arguments	// RooAbsReal::plotOn arguments
	RooCmdArg DrawOption(const char* opt) ;	RooCmdArg DrawOption(const char* opt) ;
	RooCmdArg Normalization(Double_t scaleFactor) ;	RooCmdArg Normalization(Double_t scaleFactor) ;
	RooCmdArg Slice(const RooArgSet& sliceSet) ;	RooCmdArg Slice(const RooArgSet& sliceSet) ;
	RooCmdArg Slice(RooCategory& cat, const char* label) ;	RooCmdArg Slice(RooCategory& cat, const char* label) ;
	RooCmdArg Project(const RooArgSet& projSet) ;	RooCmdArg Project(const RooArgSet& projSet) ;
	RooCmdArg ProjWData(const RooAbsData& projData, Bool_t binData=kFALSE) ;	RooCmdArg ProjWData(const RooAbsData& projData, Bool_t binData=kFALSE) ;
	RooCmdArg ProjWData(const RooArgSet& projSet, const RooAbsData& projData, B ool_t binData=kFALSE) ;	RooCmdArg ProjWData(const RooArgSet& projSet, const RooAbsData& projData, B ool_t binData=kFALSE) ;
	RooCmdArg Asymmetry(const RooCategory& cat) ;	RooCmdArg Asymmetry(const RooCategory& cat) ;

	skipping to change at line 138	skipping to change at line 139
	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) ;
	RooCmdArg OwnLinked() ;	RooCmdArg OwnLinked() ;

	// 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, Int_t interleave=0) ;

	// RooAbsPdf::printLatex arguments	// RooAbsPdf::printLatex arguments
	RooCmdArg Columns(Int_t ncol) ;	RooCmdArg Columns(Int_t ncol) ;
	RooCmdArg OutputFile(const char* fileName) ;	RooCmdArg OutputFile(const char* fileName) ;
	RooCmdArg Format(const char* format, Int_t sigDigit) ;	RooCmdArg Format(const char* format, Int_t sigDigit) ;
	RooCmdArg Format(const char* what, const RooCmdArg& arg1=RooCmdArg::none(), const RooCmdArg& arg2=RooCmdArg::none(),	RooCmdArg Format(const char* what, const RooCmdArg& arg1=RooCmdArg::none(), const RooCmdArg& arg2=RooCmdArg::none(),
	const RooCmdArg& arg3=RooCmdArg::none(),const RooCmdArg& a rg4=RooCmdArg::none(),	const RooCmdArg& arg3=RooCmdArg::none(),const RooCmdArg& a rg4=RooCmdArg::none(),
	const RooCmdArg& arg5=RooCmdArg::none(),const RooCmdArg& a rg6=RooCmdArg::none(),	const RooCmdArg& arg5=RooCmdArg::none(),const RooCmdArg& a rg6=RooCmdArg::none(),
	const RooCmdArg& arg7=RooCmdArg::none(),const RooCmdArg& a rg8=RooCmdArg::none()) ;	const RooCmdArg& arg7=RooCmdArg::none(),const RooCmdArg& a rg8=RooCmdArg::none()) ;
	RooCmdArg Sibling(const RooAbsCollection& sibling) ;	RooCmdArg Sibling(const RooAbsCollection& sibling) ;

	skipping to change at line 286	skipping to change at line 287
	RooCmdArg SplitParamConstrained(const RooRealVar& var, const RooAbsCategory & cat, const char* rsname) ;	RooCmdArg SplitParamConstrained(const RooRealVar& var, const RooAbsCategory & cat, const char* rsname) ;
	RooCmdArg Restrict(const char* catName, const char* stateNameList) ;	RooCmdArg Restrict(const char* catName, const char* stateNameList) ;

	// RooAbsPdf::createCdf() arguments	// RooAbsPdf::createCdf() arguments
	RooCmdArg SupNormSet(const RooArgSet& nset) ;	RooCmdArg SupNormSet(const RooArgSet& nset) ;
	RooCmdArg ScanParameters(Int_t nbins,Int_t intOrder) ;	RooCmdArg ScanParameters(Int_t nbins,Int_t intOrder) ;
	RooCmdArg ScanNumCdf() ;	RooCmdArg ScanNumCdf() ;
	RooCmdArg ScanAllCdf() ;	RooCmdArg ScanAllCdf() ;
	RooCmdArg ScanNoCdf() ;	RooCmdArg ScanNoCdf() ;


		// Generic container arguments (to be able to supply more command line argu
		ments)
		RooCmdArg MultiArg(const RooCmdArg& arg1, const RooCmdArg& arg2,
		const RooCmdArg& arg3=RooCmdArg::none(),const RooCmdArg&
		arg4=RooCmdArg::none(),
		const RooCmdArg& arg5=RooCmdArg::none(),const RooCmdArg&
		arg6=RooCmdArg::none(),
		const RooCmdArg& arg7=RooCmdArg::none(),const RooCmdArg&
		arg8=RooCmdArg::none()) ;

	RooConstVar& RooConst(Double_t val) ;	RooConstVar& RooConst(Double_t val) ;

	}	}

	namespace RooFitShortHand {	namespace RooFitShortHand {

	RooArgSet S(const RooAbsArg& v1) ;	RooArgSet S(const RooAbsArg& v1) ;
	RooArgSet S(const RooAbsArg& v1, const RooAbsArg& v2) ;	RooArgSet S(const RooAbsArg& v1, const RooAbsArg& v2) ;
	RooArgSet S(const RooAbsArg& v1, const RooAbsArg& v2, const RooAbsArg& v3) ;	RooArgSet S(const RooAbsArg& v1, const RooAbsArg& v2, const RooAbsArg& v3) ;
	RooArgSet S(const RooAbsArg& v1, const RooAbsArg& v2, const RooAbsArg& v3, const RooAbsArg& v4) ;	RooArgSet S(const RooAbsArg& v1, const RooAbsArg& v2, const RooAbsArg& v3, const RooAbsArg& v4) ;

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

	RooMinimizer.h	RooMinimizer.h
	/************************************************************************ *	/************************************************************************ *
	* Project: RooFit *	* Project: RooFit *
	* Package: RooFitCore *	* Package: RooFitCore *

	* File: $Id: RooMinimizer.h 47307 2012-11-15 12:12:32Z wouter $	* File: $Id: RooMinimizer.h 49228 2013-04-12 10:56:12Z 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 *
	* AL, Alfio Lazzaro, INFN Milan, alfio.lazzaro@mi.infn.it *	* AL, Alfio Lazzaro, INFN Milan, alfio.lazzaro@mi.infn.it *
	* *	* *
	* *	* *
	* 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 105	skipping to change at line 105

	Int_t _printLevel ;	Int_t _printLevel ;
	Int_t _status ;	Int_t _status ;
	Bool_t _optConst ;	Bool_t _optConst ;
	Bool_t _profile ;	Bool_t _profile ;
	RooAbsReal* _func ;	RooAbsReal* _func ;

	Bool_t _verbose ;	Bool_t _verbose ;
	TStopwatch _timer ;	TStopwatch _timer ;
	TStopwatch _cumulTimer ;	TStopwatch _cumulTimer ;

		Bool_t _profileStart ;

	TMatrixDSym* _extV ;	TMatrixDSym* _extV ;

	RooMinimizerFcn *_fcn;	RooMinimizerFcn *_fcn;
	std::string _minimizerType;	std::string _minimizerType;

	static ROOT::Fit::Fitter *_theFitter ;	static ROOT::Fit::Fitter *_theFitter ;

	std::vector<std::pair<std::string,int> > _statusHistory ;	std::vector<std::pair<std::string,int> > _statusHistory ;


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

	RooNovosibirsk.h	RooNovosibirsk.h

	skipping to change at line 40	skipping to change at line 40
	// own local versions.	// own local versions.
	RooNovosibirsk() {} ;	RooNovosibirsk() {} ;
	RooNovosibirsk(const char name, const char title,	RooNovosibirsk(const char name, const char title,
	RooAbsReal& _x, RooAbsReal& _peak,	RooAbsReal& _x, RooAbsReal& _peak,
	RooAbsReal& _width, RooAbsReal& _tail);	RooAbsReal& _width, RooAbsReal& _tail);

	RooNovosibirsk(const RooNovosibirsk& other,const char* name=0) ;	RooNovosibirsk(const RooNovosibirsk& other,const char* name=0) ;

	virtual TObject* clone(const char* newname) const { return new RooNovosib irsk(*this,newname); }	virtual TObject* clone(const char* newname) const { return new RooNovosib irsk(*this,newname); }


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

	// An empty constructor is usually ok	// An empty constructor is usually ok
	inline virtual ~RooNovosibirsk() { }	inline virtual ~RooNovosibirsk() { }

	protected:	protected:
	RooRealProxy x;	RooRealProxy x;
	RooRealProxy width;	RooRealProxy width;
	RooRealProxy peak;	RooRealProxy peak;
	RooRealProxy tail;	RooRealProxy tail;
	Double_t evaluate() const;	Double_t evaluate() const;


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

	RooRealMPFE.h	RooRealMPFE.h

	skipping to change at line 24	skipping to change at line 24
	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
	************************************************************************ */	************************************************************************ */
	#ifndef ROO_REAL_MPFE	#ifndef ROO_REAL_MPFE
	#define ROO_REAL_MPFE	#define ROO_REAL_MPFE

	#include "RooAbsReal.h"	#include "RooAbsReal.h"
	#include "RooRealProxy.h"	#include "RooRealProxy.h"
	#include "RooListProxy.h"	#include "RooListProxy.h"
	#include "RooArgList.h"	#include "RooArgList.h"
	#include "RooMPSentinel.h"	#include "RooMPSentinel.h"

		#include "TStopwatch.h"
		#include <vector>

	class RooArgSet ;	class RooArgSet ;

	class RooRealMPFE : public RooAbsReal {	class RooRealMPFE : public RooAbsReal {
	public:	public:
	// Constructors, assignment etc	// Constructors, assignment etc
	RooRealMPFE(const char name, const char title, RooAbsReal& arg, Bool_t calcInline=kFALSE) ;	RooRealMPFE(const char name, const char title, RooAbsReal& arg, Bool_t calcInline=kFALSE) ;
	RooRealMPFE(const RooRealMPFE& other, const char* name=0);	RooRealMPFE(const RooRealMPFE& other, const char* name=0);
	virtual TObject* clone(const char* newname) const { return new RooRealMPF E(*this,newname); }	virtual TObject* clone(const char* newname) const { return new RooRealMPF E(*this,newname); }
	virtual ~RooRealMPFE();	virtual ~RooRealMPFE();

	skipping to change at line 45	skipping to change at line 47
	void calculate() const ;	void calculate() const ;
	virtual Double_t getValV(const RooArgSet* nset=0) const ;	virtual Double_t getValV(const RooArgSet* nset=0) const ;
	void standby() ;	void standby() ;

	void setVerbose(Bool_t clientFlag=kTRUE, Bool_t serverFlag=kTRUE) ;	void setVerbose(Bool_t clientFlag=kTRUE, Bool_t serverFlag=kTRUE) ;

	void applyNLLWeightSquared(Bool_t flag) ;	void applyNLLWeightSquared(Bool_t flag) ;

	void enableOffsetting(Bool_t flag) ;	void enableOffsetting(Bool_t flag) ;


		void followAsSlave(RooRealMPFE& master) { _updateMaster = &master ; }

	protected:	protected:

	// Function evaluation	// Function evaluation
	virtual Double_t evaluate() const ;	virtual Double_t evaluate() const ;
	friend class RooAbsTestStatistic ;	friend class RooAbsTestStatistic ;
	virtual void constOptimizeTestStatistic(ConstOpCode opcode, Bool_t doAlso Tracking=kTRUE) ;	virtual void constOptimizeTestStatistic(ConstOpCode opcode, Bool_t doAlso Tracking=kTRUE) ;

	enum State { Initialize,Client,Server,Inline } ;	enum State { Initialize,Client,Server,Inline } ;
	State _state ;	State _state ;

	enum Message { SendReal=0, SendCat=1, Calculate=2, Retrieve=3, ReturnValu e=4, Terminate=5,	enum Message { SendReal=0, SendCat=1, Calculate=2, Retrieve=3, ReturnValu e=4, Terminate=5,
	ConstOpt=6, Verbose=7, RetrieveErrors=8, SendError=9, LogEv alError=10, ApplyNLLW2=11, EnableOffset=12, CalculateNoOffset=13 } ;	ConstOpt=6, Verbose=7, RetrieveErrors=8, SendError=9, LogEv alError=10, ApplyNLLW2=11, EnableOffset=12, CalculateNoOffset=13 } ;

	void initialize() ;	void initialize() ;
	void initVars() ;	void initVars() ;
	void serverLoop() ;	void serverLoop() ;

	void doApplyNLLW2(Bool_t flag) ;	void doApplyNLLW2(Bool_t flag) ;

	RooRealProxy _arg ; // Function to calculate in parallel process	RooRealProxy _arg ; // Function to calculate in parallel process


	RooListProxy _vars ; // Variables	RooListProxy _vars ; // Variables
	RooArgList _saveVars ; // Copy of variables	RooArgList _saveVars ; // Copy of variables
	mutable Bool_t _calcInProgress ;	mutable Bool_t _calcInProgress ;
	Bool_t _verboseClient ;	Bool_t _verboseClient ;
	Bool_t _verboseServer ;	Bool_t _verboseServer ;
	Bool_t _inlineMode ;	Bool_t _inlineMode ;
	mutable Bool_t _forceCalc ;	mutable Bool_t _forceCalc ;
	mutable RooAbsReal::ErrorLoggingMode _remoteEvalErrorLoggingState ;	mutable RooAbsReal::ErrorLoggingMode _remoteEvalErrorLoggingState ;
	Int_t _pid ; // PID of child process	Int_t _pid ; // PID of child process

	Int_t _pipeToClient[2] ; // Pipe to client process	Int_t _pipeToClient[2] ; // Pipe to client process
	Int_t _pipeToServer[2] ; // Pipe to server process	Int_t _pipeToServer[2] ; // Pipe to server process


		mutable std::vector<Bool_t> _valueChanged ; //! Flags if variable needs u
		pdate on server-side
		mutable std::vector<Bool_t> _constChanged ; //! Flags if variable needs u
		pdate on server-side
		RooRealMPFE* _updateMaster ; //! Update master
		mutable Bool_t _retrieveDispatched ; //!

	static RooMPSentinel _sentinel ;	static RooMPSentinel _sentinel ;

	ClassDef(RooRealMPFE,1) // Multi-process front-end for parallel calculati on of a real valued function	ClassDef(RooRealMPFE,1) // Multi-process front-end for parallel calculati on of a real valued function
	};	};

	#endif	#endif

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

	RooVectorDataStore.h	RooVectorDataStore.h
	/************************************************************************ *	/************************************************************************ *
	* Project: RooFit *	* Project: RooFit *
	* Package: RooFitCore *	* Package: RooFitCore *

	* File: $Id: RooVectorDataStore.h 48562 2013-02-13 18:17:24Z moneta $	* File: $Id: RooVectorDataStore.h 48829 2013-03-06 14:17:47Z 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 141	skipping to change at line 141
	_vec.reserve(initialCapacity) ;	_vec.reserve(initialCapacity) ;
	}	}

	RealVector(RooAbsReal* arg, UInt_t initialCapacity=100) :	RealVector(RooAbsReal* arg, UInt_t initialCapacity=100) :
	_nativeReal(arg), _real(0), _buf(0), _nativeBuf(0), _vec0(0), _tracke r(0), _nset(0) {	_nativeReal(arg), _real(0), _buf(0), _nativeBuf(0), _vec0(0), _tracke r(0), _nset(0) {
	_vec.reserve(initialCapacity) ;	_vec.reserve(initialCapacity) ;
	}	}

	virtual ~RealVector() {	virtual ~RealVector() {
	if (_tracker) delete _tracker ;	if (_tracker) delete _tracker ;

		if (_nset) delete _nset ;
	}	}

	RealVector(const RealVector& other, RooAbsReal* real=0) :	RealVector(const RealVector& other, RooAbsReal* real=0) :

	_vec(other._vec), _nativeReal(real?real:other._nativeReal), _real(rea l?real:other._real), _buf(other._buf), _nativeBuf(other._nativeBuf) {	_vec(other._vec), _nativeReal(real?real:other._nativeReal), _real(rea l?real:other._real), _buf(other._buf), _nativeBuf(other._nativeBuf), _nset( 0) {
	_vec0 = _vec.size()>0 ? &_vec.front() : 0 ;	_vec0 = _vec.size()>0 ? &_vec.front() : 0 ;
	if (other._tracker) {	if (other._tracker) {
	_tracker = new RooChangeTracker(Form("track_%s",_nativeReal->GetName ()),"tracker",other._tracker->parameters()) ;	_tracker = new RooChangeTracker(Form("track_%s",_nativeReal->GetName ()),"tracker",other._tracker->parameters()) ;
	} else {	} else {
	_tracker = 0 ;	_tracker = 0 ;
	}	}

		if (other._nset) {
		_nset = new RooArgSet(*other._nset) ;
		}
	}	}

	RealVector& operator=(const RealVector& other) {	RealVector& operator=(const RealVector& other) {
	if (&other==this) return *this ;	if (&other==this) return *this ;
	_nativeReal = other._nativeReal ;	_nativeReal = other._nativeReal ;
	_real = other._real ;	_real = other._real ;
	_buf = other._buf ;	_buf = other._buf ;
	_nativeBuf = other._nativeBuf ;	_nativeBuf = other._nativeBuf ;
	_vec = other._vec ;	_vec = other._vec ;
	_vec0 = _vec.size()>0 ? &_vec.front() : 0 ;	_vec0 = _vec.size()>0 ? &_vec.front() : 0 ;
	return *this ;	return *this ;
	}	}


	void setNset(RooArgSet* newNset) { _nset = newNset ; }	void setNset(RooArgSet* newNset) { _nset = newNset ? new RooArgSet(*new
		Nset) : 0 ; }

	RooArgSet* nset() const { return _nset ; }	RooArgSet* nset() const { return _nset ; }

	void setBufArg(RooAbsReal* arg) { _nativeReal = arg ; }	void setBufArg(RooAbsReal* arg) { _nativeReal = arg ; }
	const RooAbsReal* bufArg() const { return _nativeReal ; }	const RooAbsReal* bufArg() const { return _nativeReal ; }

	void setBuffer(RooAbsReal* real, Double_t* newBuf) {	void setBuffer(RooAbsReal* real, Double_t* newBuf) {
	_real = real ;	_real = real ;
	_buf = newBuf ;	_buf = newBuf ;
	if (_nativeBuf==0) {	if (_nativeBuf==0) {
	_nativeBuf=newBuf ;	_nativeBuf=newBuf ;

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

	RooWorkspace.h	RooWorkspace.h

	skipping to change at line 57	skipping to change at line 57
	RooWorkspace(const char* name, const char* title=0) ;	RooWorkspace(const char* name, const char* title=0) ;
	RooWorkspace(const RooWorkspace& other) ;	RooWorkspace(const RooWorkspace& other) ;
	~RooWorkspace() ;	~RooWorkspace() ;

	void exportToCint(const char* namespaceName=0) ;	void exportToCint(const char* namespaceName=0) ;

	Bool_t importClassCode(const char* pat="*", Bool_t doReplace=kFALSE) ;	Bool_t importClassCode(const char* pat="*", Bool_t doReplace=kFALSE) ;
	Bool_t importClassCode(TClass* theClass, Bool_t doReplace=kFALSE) ;	Bool_t importClassCode(TClass* theClass, Bool_t doReplace=kFALSE) ;

	// Import functions for dataset, functions, generic objects	// Import functions for dataset, functions, generic objects

	Bool_t import(const RooAbsArg& arg, const RooCmdArg& arg1=RooCmdArg(),con	Bool_t import(const RooAbsArg& arg,
	st RooCmdArg& arg2=RooCmdArg(),const RooCmdArg& arg3=RooCmdArg()) ;	const RooCmdArg& arg1=RooCmdArg(),const RooCmdArg& arg2=RooC
	Bool_t import(const RooArgSet& args, const RooCmdArg& arg1=RooCmdArg(),co	mdArg(),const RooCmdArg& arg3=RooCmdArg(),
	nst RooCmdArg& arg2=RooCmdArg(),const RooCmdArg& arg3=RooCmdArg()) ;	const RooCmdArg& arg4=RooCmdArg(),const RooCmdArg& arg5=RooC
	Bool_t import(RooAbsData& data, const RooCmdArg& arg1=RooCmdArg(),const R	mdArg(),const RooCmdArg& arg6=RooCmdArg(),
	ooCmdArg& arg2=RooCmdArg(),const RooCmdArg& arg3=RooCmdArg()) ;	const RooCmdArg& arg7=RooCmdArg(),const RooCmdArg& arg8=RooC
	Bool_t import(const char *fileSpec, const RooCmdArg& arg1=RooCmdArg(),con	mdArg(),const RooCmdArg& arg9=RooCmdArg()) ;
	st RooCmdArg& arg2=RooCmdArg(),const RooCmdArg& arg3=RooCmdArg()) ;	Bool_t import(const RooArgSet& args,
		const RooCmdArg& arg1=RooCmdArg(),const RooCmdArg& arg2=RooC
		mdArg(),const RooCmdArg& arg3=RooCmdArg(),
		const RooCmdArg& arg4=RooCmdArg(),const RooCmdArg& arg5=RooC
		mdArg(),const RooCmdArg& arg6=RooCmdArg(),
		const RooCmdArg& arg7=RooCmdArg(),const RooCmdArg& arg8=RooC
		mdArg(),const RooCmdArg& arg9=RooCmdArg()) ;
		Bool_t import(RooAbsData& data,
		const RooCmdArg& arg1=RooCmdArg(),const RooCmdArg& arg2=RooC
		mdArg(),const RooCmdArg& arg3=RooCmdArg(),
		const RooCmdArg& arg4=RooCmdArg(),const RooCmdArg& arg5=RooC
		mdArg(),const RooCmdArg& arg6=RooCmdArg(),
		const RooCmdArg& arg7=RooCmdArg(),const RooCmdArg& arg8=RooC
		mdArg(),const RooCmdArg& arg9=RooCmdArg()) ;
		Bool_t import(const char *fileSpec,
		const RooCmdArg& arg1=RooCmdArg(),const RooCmdArg& arg2=RooC
		mdArg(),const RooCmdArg& arg3=RooCmdArg(),
		const RooCmdArg& arg4=RooCmdArg(),const RooCmdArg& arg5=RooC
		mdArg(),const RooCmdArg& arg6=RooCmdArg(),
		const RooCmdArg& arg7=RooCmdArg(),const RooCmdArg& arg8=RooC
		mdArg(),const RooCmdArg& arg9=RooCmdArg()) ;
	Bool_t import(TObject& object, Bool_t replaceExisting=kFALSE) ;	Bool_t import(TObject& object, Bool_t replaceExisting=kFALSE) ;
	Bool_t import(TObject& object, const char* aliasName, Bool_t replaceExist ing=kFALSE) ;	Bool_t import(TObject& object, const char* aliasName, Bool_t replaceExist ing=kFALSE) ;

	// Transaction management interface for multi-step import operations	// Transaction management interface for multi-step import operations
	Bool_t startTransaction() ;	Bool_t startTransaction() ;
	Bool_t cancelTransaction() ;	Bool_t cancelTransaction() ;
	Bool_t commitTransaction() ;	Bool_t commitTransaction() ;

	// Named set management	// Named set management
	Bool_t defineSet(const char* name, const RooArgSet& aset, Bool_t importMi ssing=kFALSE) ;	Bool_t defineSet(const char* name, const RooArgSet& aset, Bool_t importMi ssing=kFALSE) ;
	Bool_t defineSet(const char* name, const char* contentList) ;	Bool_t defineSet(const char* name, const char* contentList) ;
	Bool_t extendSet(const char* name, const char* newContents) ;	Bool_t extendSet(const char* name, const char* newContents) ;
	Bool_t renameSet(const char* name, const char* newName) ;	Bool_t renameSet(const char* name, const char* newName) ;
	Bool_t removeSet(const char* name) ;	Bool_t removeSet(const char* name) ;
	const RooArgSet* set(const char* name) ;	const RooArgSet* set(const char* name) ;

	// Import, load and save parameter value snapshots	// Import, load and save parameter value snapshots
	Bool_t saveSnapshot(const char* name, const char* paramNames) ;	Bool_t saveSnapshot(const char* name, const char* paramNames) ;
	Bool_t saveSnapshot(const char* name, const RooArgSet& params, Bool_t imp ortValues=kFALSE) ;	Bool_t saveSnapshot(const char* name, const RooArgSet& params, Bool_t imp ortValues=kFALSE) ;
	Bool_t loadSnapshot(const char* name) ;	Bool_t loadSnapshot(const char* name) ;

		const RooArgSet* getSnapshot(const char* name) const ;

	void merge(const RooWorkspace& /other/) {} ;	void merge(const RooWorkspace& /other/) {} ;

	// Join p.d.f.s and datasets for simultaneous analysis	// Join p.d.f.s and datasets for simultaneous analysis
	// RooAbsPdf* joinPdf(const char* jointPdfName, const char* indexName, const char* inputMapping) ;	// RooAbsPdf* joinPdf(const char* jointPdfName, const char* indexName, const char* inputMapping) ;
	// RooAbsData* joinData(const char* jointDataName, const char* indexNam e, const char* inputMapping) ;	// RooAbsData* joinData(const char* jointDataName, const char* indexNam e, const char* inputMapping) ;

	// Accessor functions	// Accessor functions
	RooAbsPdf* pdf(const char* name) const ;	RooAbsPdf* pdf(const char* name) const ;
	RooAbsReal* function(const char* name) const ;	RooAbsReal* function(const char* name) const ;

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

	Rule.h	Rule.h

	// @(#)root/tmva $Id: Rule.h 40005 2011-06-27 15:29:10Z stelzer $	// @(#)root/tmva $Id: Rule.h 48991 2013-03-28 15:25:11Z rdm $
	// Author: Andreas Hoecker, Joerg Stelzer, Fredrik Tegenfeldt, Helge Voss	// Author: Andreas Hoecker, Joerg Stelzer, Fredrik Tegenfeldt, 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 : Rule *	* Class : Rule *
	* *	* *
	* Description: *	* Description: *
	* A class describung a 'rule' *	* A class describung a 'rule' *
	* Each internal node of a tree defines a rule from all the parental n odes. *	* Each internal node of a tree defines a rule from all the parental n odes. *

	skipping to change at line 58	skipping to change at line 58
	namespace TMVA {	namespace TMVA {

	class RuleEnsemble;	class RuleEnsemble;
	class MsgLogger;	class MsgLogger;
	class Rule;	class Rule;

	ostream& operator<<( ostream& os, const Rule & rule );	ostream& operator<<( ostream& os, const Rule & rule );

	class Rule {	class Rule {


	// ouput operator for a Rule	// output operator for a Rule
	friend ostream& operator<< ( ostream& os, const Rule & rule );	friend ostream& operator<< ( ostream& os, const Rule & rule );

	public:	public:

	// main constructor	// main constructor
	Rule( RuleEnsemble re, const std::vector< const TMVA::Node > & nod es );	Rule( RuleEnsemble re, const std::vector< const TMVA::Node > & nod es );

	// main constructor	// main constructor
	Rule( RuleEnsemble *re );	Rule( RuleEnsemble *re );


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

	SVector.h	SVector.h

	// @(#)root/smatrix:$Id: SVector.h 21553 2007-12-21 10:55:46Z moneta $	// @(#)root/smatrix:$Id: SVector.h 48991 2013-03-28 15:25:11Z rdm $
	// Author: T. Glebe, L. Moneta, J. Palacios 2005	// Author: T. Glebe, L. Moneta, J. Palacios 2005

	#ifndef ROOT_Math_SVector	#ifndef ROOT_Math_SVector
	#define ROOT_Math_SVector	#define ROOT_Math_SVector
	/********************************************************************	/********************************************************************
	//	//
	// source:	// source:
	//	//
	// type: source code	// type: source code
	//	//

	skipping to change at line 289	skipping to change at line 289
	template <class A>	template <class A>
	SVector<T,D>& operator*=(const VecExpr<A,T,D>& rhs);	SVector<T,D>& operator*=(const VecExpr<A,T,D>& rhs);
	/// self element-wise division with a vector expression	/// self element-wise division with a vector expression
	template <class A>	template <class A>
	SVector<T,D>& operator/=(const VecExpr<A,T,D>& rhs);	SVector<T,D>& operator/=(const VecExpr<A,T,D>& rhs);

	#endif	#endif
	#endif	#endif

	/** @name --- Expert functions --- */	/** @name --- Expert functions --- */

	/// transform vector into a vector of lenght 1	/// transform vector into a vector of length 1
	SVector<T,D>& Unit();	SVector<T,D>& Unit();
	/// place a sub-vector starting from the given position	/// place a sub-vector starting from the given position
	template <unsigned int D2>	template <unsigned int D2>
	SVector<T,D>& Place_at(const SVector<T,D2>& rhs, unsigned int row);	SVector<T,D>& Place_at(const SVector<T,D2>& rhs, unsigned int row);
	/// place a sub-vector expression starting from the given position	/// place a sub-vector expression starting from the given position
	template <class A, unsigned int D2>	template <class A, unsigned int D2>
	SVector<T,D>& Place_at(const VecExpr<A,T,D2>& rhs, unsigned int row);	SVector<T,D>& Place_at(const VecExpr<A,T,D2>& rhs, unsigned int row);

	/**	/**
	return a subvector of size N starting at the value row	return a subvector of size N starting at the value row

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

	TChain.h	TChain.h

	// @(#)root/tree:$Id: TChain.h 48256 2013-01-10 14:24:07Z axel $	// @(#)root/tree:$Id: TChain.h 49055 2013-04-01 13:18:39Z pcanal $
	// Author: Rene Brun 03/02/97	// Author: Rene Brun 03/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. *
	*************************************************************************/	*************************************************************************/


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

	TClassRef.h	TClassRef.h

	// @(#)root/meta:$Id: TClassRef.h 36061 2010-10-04 16:05:51Z pcanal $	// @(#)root/meta:$Id: TClassRef.h 48980 2013-03-28 14:13:32Z 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 54	skipping to change at line 54
	void Assign(TClass *);	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&);
	inline TClassRef &operator=(const TClassRef &rhs) {	inline TClassRef &operator=(const TClassRef &rhs) {
	// Inline implementation of operator= to speed the no-op case.	// Inline implementation of operator= to speed the no-op case.

	if (this != &rhs && fClassPtr != rhs.fClassPtr) {	if (this != &rhs && (fClassPtr == 0 \|\| fClassPtr != rhs.fClassPtr)) {
	this->Assign(rhs);	this->Assign(rhs);
	}	}
	return *this;	return *this;
	}	}
	inline TClassRef &operator=(TClass *rhs) {	inline TClassRef &operator=(TClass *rhs) {
	// Inline implementation of operator= to speed the no-op case.	// Inline implementation of operator= to speed the no-op case.
	if (this->fClassPtr != rhs) {	if (this->fClassPtr != rhs) {
	this->Assign(rhs);	this->Assign(rhs);
	}	}
	return *this;	return *this;

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

	TCollectionProxyInfo.h	TCollectionProxyInfo.h

	// @(#)root/cont:$Id: TCollectionProxyInfo.h 43515 2012-03-27 21:15:53Z pca nal $	// @(#)root/cont:$Id: TCollectionProxyInfo.h 49056 2013-04-01 13:19:26Z 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 47	skipping to change at line 47

	namespace ROOT {	namespace ROOT {

	class TCollectionProxyInfo {	class TCollectionProxyInfo {
	// This class is a place holder for the information needed	// This class is a place holder for the information needed
	// to create the proper Collection Proxy.	// to create the proper Collection Proxy.
	// This is similar to Reflex's CollFuncTable.	// This is similar to Reflex's CollFuncTable.

	public:	public:


		// Same value as TVirtualCollectionProxy.
		static const UInt_t fgIteratorArenaSize = 16; // greater than sizeof(
		void*) + sizeof(UInt_t)

		/** @class template TCollectionProxyInfo::IteratorValue
		*
		* Small helper to encapsulate whether to return the value
		* pointed to by the iterator or its address.
		*
		**/

		template <typename Cont_t, typename value> struct IteratorValue {
		static void* get(typename Cont_t::iterator &iter) {
		return (void)&(iter);
		}
		};

		template <typename Cont_t, typename value_ptr> struct IteratorValue<C
		ont_t, value_ptr*> {
		static void* get(typename Cont_t::iterator &iter) {
		return (void)(iter);
		}
		};

		/** @class template TCollectionProxyInfo::Iterators
		*
		* Small helper to implement the function to create,access and destroy
		* iterators.
		*
		**/

		template <typename Cont_t, bool large = false>
		struct Iterators {
		typedef Cont_t *PCont_t;
		typedef typename Cont_t::iterator iterator;

		static void create(void coll, void begin_arena, void *end_aren
		a) {
		PCont_t c = PCont_t(coll);
		new (*begin_arena) iterator(c->begin());
		new (*end_arena) iterator(c->end());
		}
		static void* copy(void dest_arena, const void source_ptr) {
		iterator source = (iterator )(source_ptr);
		new (dest_arena) iterator(*source);
		return dest_arena;
		}
		static void* next(void iter_loc, const void end_loc) {
		iterator end = (iterator )(end_loc);
		iterator iter = (iterator )(iter_loc);
		if (iter != end) {
		void *result = IteratorValue<Cont_t, typename Cont_t::value_
		type>::get(*iter);
		++(*iter);
		return result;
		}
		return 0;
		}
		static void destruct1(void *iter_ptr) {
		iterator start = (iterator )(iter_ptr);
		start->~iterator();
		}
		static void destruct2(void begin_ptr, void end_ptr) {
		iterator start = (iterator )(begin_ptr);
		iterator end = (iterator )(end_ptr);
		start->~iterator();
		end->~iterator();
		}
		};

		// For Vector we take an extra short cut to avoid derefencing
		// the iterator all the time and redefine the 'address' of the
		// iterator as the iterator itself. This requires special handling
		// in the looper (see TStreamerInfoAction) but is much faster.
		template <typename T> struct Iterators<std::vector<T>, false> {
		typedef std::vector<T> Cont_t;
		typedef Cont_t *PCont_t;
		typedef typename Cont_t::iterator iterator;

		static void create(void coll, void begin_arena, void *end_aren
		a) {
		PCont_t c = PCont_t(coll);
		if (c->empty()) {
		*begin_arena = 0;
		*end_arena = 0;
		return;
		}
		begin_arena = &(c->begin());
		#ifdef R__VISUAL_CPLUSPLUS
		end_arena = &((c->end()-1)) + 1; // On windows we can not der
		erence the end iterator at all.
		#else
		// coverity[past_the_end] Safe on other platforms
		end_arena = &(c->end());
		#endif
		}
		static void* copy(void dest, const void source) {
		(void)dest = (void*)(const_cast<void>(source));
		return dest;
		}
		static void* next(void * /* iter_loc /, const void /* end_loc *
		/) {
		// Should not be used.
		R__ASSERT(0 && "Intentionally not implemented, do not use.");
		return 0;
		}
		static void destruct1(void * /* iter_ptr */) {
		// Nothing to do
		}
		static void destruct2(void * /* begin_ptr /, void /* end_ptr */
		) {
		// Nothing to do
		}
		};

		template <typename Cont_t> struct Iterators<Cont_t, /* large= */ true
		> {
		typedef Cont_t *PCont_t;
		typedef typename Cont_t::iterator iterator;

		static void create(void coll, void begin_arena, void *end_aren
		a) {
		PCont_t c = PCont_t(coll);
		*begin_arena = new iterator(c->begin());
		*end_arena = new iterator(c->end());
		}
		static void* copy(void * /dest_arena/, const void *source_ptr) {
		iterator source = (iterator )(source_ptr);
		void iter = new iterator(source);
		return iter;
		}
		static void* next(void iter_loc, const void end_loc) {
		iterator end = (iterator )(end_loc);
		iterator iter = (iterator )(iter_loc);
		if (iter != end) {
		void *result = IteratorValue<Cont_t, typename Cont_t::value_
		type>::get(*iter);
		++(*iter);
		return result;
		}
		return 0;
		}
		static void destruct1(void *begin_ptr) {
		iterator start = (iterator )(begin_ptr);
		delete start;
		}
		static void destruct2(void begin_ptr, void end_ptr) {
		iterator start = (iterator )(begin_ptr);
		iterator end = (iterator )(end_ptr);
		delete start;
		delete end;
		}
		};

	/** @class TCollectionProxyInfo::Environ TCollectionProxyInfo.h TCollecti onProxyInfo.h	/** @class TCollectionProxyInfo::Environ TCollectionProxyInfo.h TCollecti onProxyInfo.h
	*	*
	* Small helper to save proxy environment in the event of	* Small helper to save proxy environment in the event of
	* recursive calls.	* recursive calls.
	*	*
	* @author M.Frank	* @author M.Frank
	* @version 1.0	* @version 1.0
	* @date 10/10/2004	* @date 10/10/2004
	*/	*/
	#ifndef __CINT__	#ifndef __CINT__

	skipping to change at line 167	skipping to change at line 310
	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 *what, size_t size) {	static void* construct(void *what, size_t size) {
	PValue_t m = PValue_t(what);	PValue_t m = PValue_t(what);
	for (size_t i=0; i<size; ++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* collect(void* env) {	static void* collect(void coll, void array) {
	PEnv_t e = PEnv_t(env);	PCont_t c = PCont_t(coll);
	PCont_t c = PCont_t(e->fObject);	PValue_t m = PValue_t(array);
	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 *what, size_t size) {	static void destruct(void *what, size_t size) {
	PValue_t m = PValue_t(what);	PValue_t m = PValue_t(what);
	for (size_t i=0; i < size; ++i, ++m )	for (size_t i=0; i < size; ++i, ++m )
	m->~Value_t();	m->~Value_t();
	}	}


		static const bool fgLargeIterator = sizeof(typename Cont_t::iterator)
		> fgIteratorArenaSize;
		typedef Iterators<Cont_t,fgLargeIterator> Iterators_t;

	};	};

	/** @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

	skipping to change at line 294	skipping to change at line 440
	size_t fValueDiff;	size_t fValueDiff;
	int fValueOffset;	int fValueOffset;
	void* (fSizeFunc)(void);	void* (fSizeFunc)(void);
	void (fResizeFunc)(void,size_t);	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,size_t);	void* (fConstructFunc)(void,size_t);
	void (fDestructFunc)(void,size_t);	void (fDestructFunc)(void,size_t);
	void* (fFeedFunc)(void,void*,size_t);	void* (fFeedFunc)(void,void*,size_t);

	void* (fCollectFunc)(void);	void* (fCollectFunc)(void,void*);
	void* (*fCreateEnv)();	void* (*fCreateEnv)();

	// Set of function of direct iteration of the collections.	// Set of function of direct iteration of the collections.

	void (fGetIterators)(void collection, void &begin_arena, void &en d_arena);	void (fCreateIterators)(void collection, void *begin_arena, void *end_arena);
	// begin_arena and end_arena should contain the location of memory ar ena of size fgIteratorSize.	// 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)	// 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.	// 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);	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.	// 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)	// 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.	// 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);	void* (fNext)(void iter, const void *end);
	// iter and end should be pointer to respectively an iterator to be i ncremented and the result of colleciton.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.	// '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	// 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.	// which case 'Next' will return the value of the pointer.

	void (fDeleteSingleIterator)(void iter);	void (fDeleteSingleIterator)(void iter);
	void (fDeleteTwoIterators)(void begin, void *end);	void (fDeleteTwoIterators)(void begin, void *end);
	// If the sizeof iterator is greater than fgIteratorArenaSize, call d elete on the addresses,	// If the sizeof iterator is greater than fgIteratorArenaSize, call d elete on the addresses,
	// Otherwise just call the iterator's destructor.	// Otherwise just call the iterator's destructor.


	skipping to change at line 332	skipping to change at line 478
	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,size_t),	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,size_t),	void* (construct_func)(void,size_t),
	void (destruct_func)(void,size_t),	void (destruct_func)(void,size_t),
	void* (feed_func)(void,void*,size_t),	void* (feed_func)(void,void*,size_t),

	void* (collect_func)(void),	void* (collect_func)(void,void*),
	void* (*create_env)()	void* (*create_env)(),
		void (getIterators)(void collection, void **
		begin_arena, void **end_arena) = 0,
		void* (copyIterator)(void dest, const void *s
		ource) = 0,
		void* (next)(void iter, const void *end) = 0,
		void (deleteSingleIterator)(void iter) = 0,
		void (deleteTwoIterators)(void begin, void *
		end) = 0
	) :	) :
	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	fCreateIterators(getIterators),fCopyIterator(copyIterator),fNext(n
	),fDeleteTwoIterators(0)	ext),
		fDeleteSingleIterator(deleteSingleIterator),fDeleteTwoIterators(de
		leteTwoIterators)
	{	{
	}	}

	/// 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 367	skipping to change at line 519
	T::value_offset(),	T::value_offset(),
	T::size,	T::size,
	T::resize,	T::resize,
	T::clear,	T::clear,
	T::first,	T::first,
	T::next,	T::next,
	T::construct,	T::construct,
	T::destruct,	T::destruct,
	T::feed,	T::feed,
	T::collect,	T::collect,

	T::Env_t::Create);	T::Env_t::Create,
		T::Iterators_t::create,
		T::Iterators_t::copy,
		T::Iterators_t::next,
		T::Iterators_t::destruct1,
		T::Iterators_t::destruct2);
	}	}

	template <class T> static ROOT::TCollectionProxyInfo Get(const T&) {	template <class T> static ROOT::TCollectionProxyInfo Get(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::Get(TCollectionProxyInfo::Pu shback< vector<string> >()));	// ::ROOT::TCollectionProxyInfo::Get(TCollectionProxyInfo::Pu shback< vector<string> >()));

	PairHolder<TYPENAME T::Value_t, TYPENAME T::Value_t>* p =	PairHolder<TYPENAME T::Value_t, TYPENAME T::Value_t>* p =

	skipping to change at line 444	skipping to change at line 601
	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*,size_t) {	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 coll, void array) {
	PEnv_t e = PEnv_t(env);	PCont_t c = PCont_t(coll);
	PCont_t c = PCont_t(e->fObject);	PValue_t m = PValue_t(array); // 'start' is a buffer outside the c
	PValue_t m = PValue_t(e->fStart); // 'start' is a buffer outside t	ontainer.
	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*,size_t) {	static void destruct(void*,size_t) {
	// Nothing to destruct.	// Nothing to destruct.
	}	}


		//static const bool fgLargeIterator = sizeof(Cont_t::iterator) > fgIt
		eratorArenaSize;
		//typedef Iterators<Cont_t,fgLargeIterator> Iterators_t;

		struct Iterators {
		typedef Cont_t *PCont_t;
		typedef Cont_t::iterator iterator;

		static void create(void coll, void begin_arena, void *end_aren
		a) {
		PCont_t c = PCont_t(coll);
		new (*begin_arena) iterator(c->begin());
		new (*end_arena) iterator(c->end());
		}
		static void* copy(void dest_arena, const void source_ptr) {
		const iterator source = (const iterator )(source_ptr);
		new (dest_arena) iterator(*source);
		return dest_arena;
		}
		static void* next(void iter_loc, const void end_loc) {
		const iterator end = (const iterator )(end_loc);
		iterator iter = (iterator )(iter_loc);
		if (iter != end) {
		++(*iter);
		//if (iter != end) {
		// return IteratorValue<Cont_t, Cont_t::value_type>::get(*
		iter);
		//}
		}
		return 0;
		}
		static void destruct1(void *iter_ptr) {
		iterator start = (iterator )(iter_ptr);
		start->~iterator();
		}
		static void destruct2(void begin_ptr, void end_ptr) {
		iterator start = (iterator )(begin_ptr);
		iterator end = (iterator )(end_ptr);
		start->~iterator();
		end->~iterator();
		}
		};
		typedef Iterators Iterators_t;

	};	};

	template <> struct TCollectionProxyInfo::Pushback<std::vector<bool> > : public TCollectionProxyInfo::Type<std::vector<Bool_t> > {	template <> struct TCollectionProxyInfo::Pushback<std::vector<bool> > : public TCollectionProxyInfo::Type<std::vector<Bool_t> > {
	typedef std::vector<Bool_t> Cont_t;	typedef std::vector<Bool_t> 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;

	skipping to change at line 540	skipping to change at line 738
	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*,size_t) {	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 coll, void array) {
	PEnv_t e = PEnv_t(env);	PCont_t c = PCont_t(coll);
	PCont_t c = PCont_t(e->fObject);	PValue_t m = PValue_t(array); // 'start' is a buffer outside the c
	PValue_t m = PValue_t(e->fStart); // 'start' is a buffer outside t	ontainer.
	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*,size_t) {	static void destruct(void*,size_t) {
	// Nothing to destruct.	// Nothing to destruct.
	}	}
	};	};

	template <typename Bitset_t>	template <typename Bitset_t>

End of changes. 14 change blocks.
	24 lines changed or deleted	240 lines changed or added

	TDatabasePDG.h	TDatabasePDG.h

	// @(#)root/eg:$Id: TDatabasePDG.h 43982 2012-04-27 11:01:54Z pcanal $	// @(#)root/eg:$Id: TDatabasePDG.h 49276 2013-04-19 12:33:41Z moneta $
	// Author: Pasha Murat 12/02/99	// Author: Pasha Murat 12/02/99

	/*************************************************************************	/*************************************************************************
	* 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 33	skipping to change at line 33
	class TExMap;	class TExMap;

	class TDatabasePDG: public TNamed {	class TDatabasePDG: public TNamed {

	protected:	protected:
	static TDatabasePDG *fgInstance; // protect against multiple inst ances	static TDatabasePDG *fgInstance; // protect against multiple inst ances
	THashList *fParticleList; // list of PDG particles	THashList *fParticleList; // list of PDG particles
	TObjArray *fListOfClasses; // list of classes (leptons etc. )	TObjArray *fListOfClasses; // list of classes (leptons etc. )
	mutable TExMap *fPdgMap; //!hash-map from pdg-code to par ticle	mutable TExMap *fPdgMap; //!hash-map from pdg-code to par ticle


		// make copy-constructor and assigment protected since class cannot be c opied
	TDatabasePDG(const TDatabasePDG& db)	TDatabasePDG(const TDatabasePDG& db)
	: TNamed(db), fParticleList(db.fParticleList),	: TNamed(db), fParticleList(db.fParticleList),
	fListOfClasses(db.fListOfClasses), fPdgMap(0) { }	fListOfClasses(db.fListOfClasses), fPdgMap(0) { }

	TDatabasePDG& operator=(const TDatabasePDG& db)	TDatabasePDG& operator=(const TDatabasePDG& db)

	{if(this!=&db) {TNamed::operator=(db); fParticleList=db.fParticleList;	{if(this!=&db) {TNamed::operator=(db); fParticleList=db.fParticleList;
	fListOfClasses=db.fListOfClasses;} return *this;}	fListOfClasses=db.fListOfClasses; fPdgMap=db.fPdgMap;}
		return *this;}

	void BuildPdgMap() const;	void BuildPdgMap() const;

	public:	public:

	TDatabasePDG();	TDatabasePDG();
	virtual ~TDatabasePDG();	virtual ~TDatabasePDG();

	static TDatabasePDG* Instance();	static TDatabasePDG* Instance();


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

	TEveVSD.h	TEveVSD.h

	// @(#)root/eve:$Id: TEveVSD.h 31363 2009-11-21 11:31:07Z matevz $	// @(#)root/eve:$Id: TEveVSD.h 48991 2013-03-28 15:25:11Z rdm $
	// 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 67	skipping to change at line 67
	virtual void DeleteTrees();	virtual void DeleteTrees();

	virtual void CreateBranches();	virtual void CreateBranches();
	virtual void WriteTrees();	virtual void WriteTrees();

	virtual void LoadTrees();	virtual void LoadTrees();
	virtual void SetBranchAddresses();	virtual void SetBranchAddresses();

	static void DisableTObjectStreamersForVSDStruct();	static void DisableTObjectStreamersForVSDStruct();


	ClassDef(TEveVSD, 1); // Visualization Summary Data - a collection of tr ees holding standard event data in experiment independant format.	ClassDef(TEveVSD, 1); // Visualization Summary Data - a collection of tr ees holding standard event data in experiment independent format.
	};	};

	#endif	#endif

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

	TFunction.h	TFunction.h

	// @(#)root/meta:$Id: TFunction.h 42030 2011-11-15 22:23:12Z pcanal $	// @(#)root/meta:$Id: TFunction.h 48771 2013-02-28 19:49:49Z pcanal $
	// Author: Fons Rademakers 07/02/97	// Author: Fons Rademakers 07/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 51	skipping to change at line 51
	public:	public:
	TFunction(MethodInfo_t *info = 0);	TFunction(MethodInfo_t *info = 0);
	TFunction(const TFunction &orig);	TFunction(const TFunction &orig);
	TFunction& operator=(const TFunction &rhs);	TFunction& operator=(const TFunction &rhs);
	virtual ~TFunction();	virtual ~TFunction();
	virtual TObject Clone(const char newname="") const;	virtual TObject Clone(const char newname="") const;
	virtual const char *GetMangledName() const;	virtual const char *GetMangledName() const;
	virtual const char *GetPrototype() const;	virtual const char *GetPrototype() const;
	const char *GetSignature();	const char *GetSignature();
	const char *GetReturnTypeName() const;	const char *GetReturnTypeName() const;

		std::string GetReturnTypeNormalizedName() const;
	TList *GetListOfMethodArgs();	TList *GetListOfMethodArgs();
	Int_t GetNargs() const;	Int_t GetNargs() const;
	Int_t GetNargsOpt() const;	Int_t GetNargsOpt() const;
	void *InterfaceMethod() const;	void *InterfaceMethod() const;
	Long_t Property() const;	Long_t Property() const;

	ClassDef(TFunction,0) //Dictionary for global function	ClassDef(TFunction,0) //Dictionary for global function
	};	};

	#endif	#endif

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

	TGLCamera.h	TGLCamera.h

	// @(#)root/gl:$Id: TGLCamera.h 46586 2012-10-16 20:43:26Z matevz $	// @(#)root/gl:$Id: TGLCamera.h 49071 2013-04-04 05:21:42Z 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. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TGLCamera	#ifndef ROOT_TGLCamera
	#define ROOT_TGLCamera	#define ROOT_TGLCamera

	#include "TGLUtil.h"	#include "TGLUtil.h"
	#include "TGLBoundingBox.h"	#include "TGLBoundingBox.h"
	#include "TPoint.h"	#include "TPoint.h"

		#include "TObject.h"

	#include <cassert>	#include <cassert>
	#include <cmath>	#include <cmath>

	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// //	// //
	// TGLCamera //	// TGLCamera //
	// //	// //
	// Abstract base camera class - concrete classes for orthographic and //	// Abstract base camera class - concrete classes for orthographic and //
	// persepctive cameras derive from it. This class maintains values for //	// persepctive cameras derive from it. This class maintains values for //

	skipping to change at line 42	skipping to change at line 43
	// iv) Expanded frustum interest box //	// iv) Expanded frustum interest box //
	// //	// //
	// It provides methods for various projection, overlap and intersection //	// It provides methods for various projection, overlap and intersection //
	// tests for viewport and world locations, against the true frustum and //	// tests for viewport and world locations, against the true frustum and //
	// expanded interest box, and for extracting eye position and direction.//	// expanded interest box, and for extracting eye position and direction.//
	// //	// //
	// It also defines the pure virtual manipulation interface methods the //	// It also defines the pure virtual manipulation interface methods the //
	// concrete ortho and prespective classes must implement. //	// concrete ortho and prespective classes must implement. //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////


	class TGLCamera	class TGLCamera : public TObject
	{	{
	public:	public:
	enum EFrustumPlane	enum EFrustumPlane
	{	{
	kNear = 0,	kNear = 0,
	kLeft = 1,	kLeft = 1,
	kRight = 2,	kRight = 2,
	kTop = 3,	kTop = 3,
	kBottom = 4,	kBottom = 4,
	kFar = 5,	kFar = 5,

	skipping to change at line 74	skipping to change at line 75
	static const Double_t fgInterestBoxExpansion; //! expansion c.f. aligned current frustum box	static const Double_t fgInterestBoxExpansion; //! expansion c.f. aligned current frustum box

	// Methods	// Methods
	TGLBoundingBox Frustum(Bool_t asBox = kTRUE) const; // current frustum	TGLBoundingBox Frustum(Bool_t asBox = kTRUE) const; // current frustum

	// Non-copyable class	// Non-copyable class
	TGLCamera(const TGLCamera &);	TGLCamera(const TGLCamera &);
	TGLCamera & operator=(const TGLCamera &);	TGLCamera & operator=(const TGLCamera &);

	protected:	protected:

	// Fields	// Fields
	TGLMatrix fCamBase; //! tranformation to center and rotation f	TGLMatrix fCamBase; // tranformation to center and rotation
	rom up to x vector	from up to x vector
	TGLMatrix fCamTrans; //! transformation relative to fCamTrans	TGLMatrix fCamTrans; // transformation relative to fCamTrans
	Bool_t fExternalCenter; //! use external center insead of scene ce	Bool_t fExternalCenter; // use external center insead of scene c
	nter	enter
	Bool_t fFixDefCenter; //! use fixed default center	Bool_t fFixDefCenter; // use fixed default center
	Bool_t fWasArcBalled; //! set when arc-ball rotation is used	Bool_t fWasArcBalled; // set when arc-ball rotation is used
	TGLVector3 fExtCenter; //! external camera center	TGLVector3 fExtCenter; // external camera center
	TGLVector3 fDefCenter; //! deafult camera center	TGLVector3 fDefCenter; // default camera center
	TGLVector3 fFDCenter; //! fixed deafult camera center	TGLVector3 fFDCenter; // fixed default camera center
	TGLVector3 *fCenter; //! current camera center	TGLVector3 *fCenter; //! current camera center

	mutable Double_t fNearClip; //! last applied near-clip	mutable Double_t fNearClip; //! last applied near-clip
	mutable Double_t fFarClip; //! last applied far-clip	mutable Double_t fFarClip; //! last applied far-clip

	// Set in Setup()	// Set in Setup()
	Double_t fDollyDefault; //! default distnce from viewing centre	Double_t fDollyDefault; // default distnce from viewing centre
	Double_t fDollyDistance; //! unit distance for camera movement in f	Double_t fDollyDistance; // unit distance for camera movement in f
	wd/bck direction	wd/bck direction
	Float_t fVAxisMinAngle; //! minimal allowed angle between up and fC	Float_t fVAxisMinAngle; // minimal allowed angle between u
	amTrans Z vector	p and fCamTrans Z vector

	// Internal cached matrices and frustum planes	// Internal cached matrices and frustum planes
	mutable Bool_t fCacheDirty; //! cached items dir ty?	mutable Bool_t fCacheDirty; //! cached items dir ty?
	mutable UInt_t fTimeStamp; //! timestamp	mutable UInt_t fTimeStamp; //! timestamp
	mutable TGLMatrix fLastNoPickProjM; //! no-pick projecti on matrix (cached)	mutable TGLMatrix fLastNoPickProjM; //! no-pick projecti on matrix (cached)
	mutable TGLMatrix fProjM; //! projection matri x (cached)	mutable TGLMatrix fProjM; //! projection matri x (cached)
	mutable TGLMatrix fModVM; //! modelView matrix (cached)	mutable TGLMatrix fModVM; //! modelView matrix (cached)
	mutable TGLMatrix fClipM; //! object space cli p matrix (cached)	mutable TGLMatrix fClipM; //! object space cli p matrix (cached)
	mutable TGLPlane fFrustumPlanes[kPlanesPerFrustum]; //! frustum planes (cached)	mutable TGLPlane fFrustumPlanes[kPlanesPerFrustum]; //! frustum planes (cached)


	skipping to change at line 215	skipping to change at line 216
	virtual void Configure(Double_t zoom, Double_t dolly, Double_t center[3] ,	virtual void Configure(Double_t zoom, Double_t dolly, Double_t center[3] ,
	Double_t hRotate, Double_t vRotate) = 0;	Double_t hRotate, Double_t vRotate) = 0;
	// Cameras expanded-frustum interest box	// Cameras expanded-frustum interest box
	Bool_t OfInterest(const TGLBoundingBox & box, Bool_t ignoreSize) const;	Bool_t OfInterest(const TGLBoundingBox & box, Bool_t ignoreSize) const;
	Bool_t UpdateInterest(Bool_t force);	Bool_t UpdateInterest(Bool_t force);
	void ResetInterest();	void ResetInterest();

	// Debuging - draw frustum and interest boxes	// Debuging - draw frustum and interest boxes
	void DrawDebugAids() const;	void DrawDebugAids() const;


	ClassDef(TGLCamera,0); // Camera abstract base class.	ClassDef(TGLCamera,1); // Camera abstract base class.
	};	};

	inline const TGLPlane & TGLCamera::FrustumPlane(EFrustumPlane plane) const	inline const TGLPlane & TGLCamera::FrustumPlane(EFrustumPlane plane) const
	{	{
	// Return one of the planes forming the camera frustum	// Return one of the planes forming the camera frustum
	if (fCacheDirty) {	if (fCacheDirty) {
	Error("TGLCamera::FrustumBox()", "cache dirty");	Error("TGLCamera::FrustumBox()", "cache dirty");
	}	}
	return fFrustumPlanes[plane];	return fFrustumPlanes[plane];
	}	}

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

	TGLFormat.h	TGLFormat.h

	// @(#)root/gl:$Id: TGLFormat.h 36675 2010-11-15 20:33:58Z matevz $	// @(#)root/gl:$Id: TGLFormat.h 48649 2013-02-20 08:49:29Z tpochep $
	/*************************************************************************	/*************************************************************************
	* 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


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

	#include <vector>	#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.

	skipping to change at line 34	skipping to change at line 35
	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:
	enum EFormatOptions
	{
	kNone = 0,
	kDoubleBuffer = 1,
	kDepth = 2,
	kAccum = 4,
	kStencil = 8,
	kStereo = 16,
	kMultiSample = 32
	};

	private:	private:
	Bool_t fDoubleBuffered;	Bool_t fDoubleBuffered;
	Bool_t fStereo;	Bool_t fStereo;
	Int_t fDepthSize;	Int_t fDepthSize;
	Int_t fAccumSize;	Int_t fAccumSize;
	Int_t fStencilSize;	Int_t fStencilSize;
	Int_t fSamples;	Int_t fSamples;

	static std::vector<Int_t> fgAvailableSamples;	static std::vector<Int_t> fgAvailableSamples;

	static Int_t GetDefaultSamples();	static Int_t GetDefaultSamples();
	static void InitAvailableSamples();	static void InitAvailableSamples();

	public:	public:
	TGLFormat();	TGLFormat();

	TGLFormat(EFormatOptions options);	TGLFormat(Rgl::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;

	Int_t GetDepthSize()const;	Int_t GetDepthSize()const;
	void SetDepthSize(Int_t depth);	void SetDepthSize(Int_t depth);

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

	TGLOrthoCamera.h	TGLOrthoCamera.h

	// @(#)root/gl:$Id: TGLOrthoCamera.h 28212 2009-04-15 11:05:29Z matevz $	// @(#)root/gl:$Id: TGLOrthoCamera.h 49071 2013-04-04 05:21:42Z 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 38	skipping to change at line 38
	// rotations about them. //	// rotations about them. //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	class TGLPaintDevice;	class TGLPaintDevice;

	class TGLOrthoCamera : public TGLCamera	class TGLOrthoCamera : public TGLCamera
	{	{
	public:	public:
	enum EType { kZOY, kXOZ, kXOY, // Pair of world axes aligned to h/v screen.	enum EType { kZOY, kXOZ, kXOY, // Pair of world axes aligned to h/v screen.

	kZnOY, kXnOZ, kXnOY }; // 'n' means preceeding axis is nega ted.	kZnOY, kXnOZ, kXnOY }; // 'n' means preceding axis is negat ed.
	private:	private:
	// Fields	// Fields

	EType fType; //! camera type	EType fType; // camera type
	Bool_t fEnableRotate; //! enable rotation	Bool_t fEnableRotate; // enable rotation
	Bool_t fDollyToZoom; //! zoom when dolly is requested	Bool_t fDollyToZoom; // zoom when dolly is requested

	// Limits - set in Setup()	// Limits - set in Setup()

	Double_t fZoomMin; //! minimum zoom factor	Double_t fZoomMin; // minimum zoom factor
	Double_t fZoomDefault; //! default zoom factor	Double_t fZoomDefault; // default zoom factor
	Double_t fZoomMax; //! maximum zoom factor	Double_t fZoomMax; // maximum zoom factor
	TGLBoundingBox fVolume; //! scene volume	TGLBoundingBox fVolume; //! scene volume

	// Current interaction	// Current interaction
	Double_t fDefXSize, fDefYSize; //! x, y size of scene from camera view	Double_t fDefXSize, fDefYSize; //! x, y size of scene from camera view

	Double_t fZoom; //! current zoom	Double_t fZoom; // current zoom

	static UInt_t fgZoomDeltaSens;	static UInt_t fgZoomDeltaSens;

	public:	public:

		TGLOrthoCamera();
	TGLOrthoCamera(EType type, const TGLVector3 & hAxis, const TGLVector3 & vAxis);	TGLOrthoCamera(EType type, const TGLVector3 & hAxis, const TGLVector3 & vAxis);
	virtual ~TGLOrthoCamera();	virtual ~TGLOrthoCamera();

	virtual Bool_t IsOrthographic() const { return kTRUE; }	virtual Bool_t IsOrthographic() const { return kTRUE; }

	virtual void Setup(const TGLBoundingBox & box, Bool_t reset=kTRUE);	virtual void Setup(const TGLBoundingBox & box, Bool_t reset=kTRUE);
	virtual void Reset();	virtual void Reset();

	virtual Bool_t Dolly(Int_t delta, Bool_t mod1, Bool_t mod2);	virtual Bool_t Dolly(Int_t delta, Bool_t mod1, Bool_t mod2);
	virtual Bool_t Zoom (Int_t delta, Bool_t mod1, Bool_t mod2);	virtual Bool_t Zoom (Int_t delta, Bool_t mod1, Bool_t mod2);

	skipping to change at line 90	skipping to change at line 91

	Double_t GetZoomMin() const { return fZoomMin; }	Double_t GetZoomMin() const { return fZoomMin; }
	Double_t GetZoomMax() const { return fZoomMax; }	Double_t GetZoomMax() const { return fZoomMax; }
	void SetZoomMin(Double_t z);	void SetZoomMin(Double_t z);
	void SetZoomMax(Double_t z);	void SetZoomMax(Double_t z);
	void SetZoomMinMax(Double_t min, Double_t max) { SetZoomMin(min); Se tZoomMax(max); }	void SetZoomMinMax(Double_t min, Double_t max) { SetZoomMin(min); Se tZoomMax(max); }

	void SetDollyToZoom(Bool_t x) { fDollyToZoom = x; }	void SetDollyToZoom(Bool_t x) { fDollyToZoom = x; }
	Bool_t GetDollyToZoom() const { return fDollyToZoom; }	Bool_t GetDollyToZoom() const { return fDollyToZoom; }


	ClassDef(TGLOrthoCamera,0) // Camera for orthographic view.	void SetZoom(Double_t x) { fZoom = x; }
		Double_t GetZoom() const { return fZoom; }

		ClassDef(TGLOrthoCamera,1) // Camera for orthographic view.
	};	};

	#endif // ROOT_TGLOrthoCamera	#endif // ROOT_TGLOrthoCamera

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

	TGLPerspectiveCamera.h	TGLPerspectiveCamera.h

	// @(#)root/gl:$Id: TGLPerspectiveCamera.h 46586 2012-10-16 20:43:26Z matev z $	// @(#)root/gl:$Id: TGLPerspectiveCamera.h 49071 2013-04-04 05:21:42Z matev z $
	// 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 29	skipping to change at line 29
	// TGLPerspectiveCamera //	// TGLPerspectiveCamera //
	// //	// //
	// Perspective projection camera - with characteristic foreshortening. //	// Perspective projection camera - with characteristic foreshortening. //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	class TGLPerspectiveCamera : public TGLCamera	class TGLPerspectiveCamera : public TGLCamera
	{	{
	private:	private:
	// Fields	// Fields

	Double_t fFOV; //!	Double_t fFOV;

	static Double_t fgFOVMin, fgFOVDefault, fgFOVMax;	static Double_t fgFOVMin, fgFOVDefault, fgFOVMax;
	static UInt_t fgFOVDeltaSens;	static UInt_t fgFOVDeltaSens;

	public:	public:

		TGLPerspectiveCamera();
	TGLPerspectiveCamera(const TGLVector3 & hAxis, const TGLVector3 & vAxis) ;	TGLPerspectiveCamera(const TGLVector3 & hAxis, const TGLVector3 & vAxis) ;
	virtual ~TGLPerspectiveCamera();	virtual ~TGLPerspectiveCamera();

	virtual Bool_t IsPerspective() const { return kTRUE; }	virtual Bool_t IsPerspective() const { return kTRUE; }

	Double_t GetFOV() const { return fFOV; }	Double_t GetFOV() const { return fFOV; }

	virtual void Setup(const TGLBoundingBox & box, Bool_t reset=kTRUE);	virtual void Setup(const TGLBoundingBox & box, Bool_t reset=kTRUE);
	virtual void Reset();	virtual void Reset();
	virtual Bool_t Zoom (Int_t delta, Bool_t mod1, Bool_t mod2);	virtual Bool_t Zoom (Int_t delta, Bool_t mod1, Bool_t mod2);
	using TGLCamera::Truck;	using TGLCamera::Truck;
	virtual Bool_t Truck(Int_t xDelta, Int_t yDelta, Bool_t mod1, Bool_t mod 2);	virtual Bool_t Truck(Int_t xDelta, Int_t yDelta, Bool_t mod1, Bool_t mod 2);
	virtual void Apply(const TGLBoundingBox & box, const TGLRect * pickRec t = 0) const;	virtual void Apply(const TGLBoundingBox & box, const TGLRect * pickRec t = 0) const;

	// External scripting control	// External scripting control
	virtual void Configure(Double_t fov, Double_t dolly, Double_t center[3],	virtual void Configure(Double_t fov, Double_t dolly, Double_t center[3],
	Double_t hRotate, Double_t vRotate);	Double_t hRotate, Double_t vRotate);


	ClassDef(TGLPerspectiveCamera,0) // Camera for perspective view.	ClassDef(TGLPerspectiveCamera,1) // Camera for perspective view.
	};	};

	#endif // ROOT_TGLPerspectiveCamera	#endif // ROOT_TGLPerspectiveCamera

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

	TGListBox.h	TGListBox.h

	// @(#)root/gui:$Id: TGListBox.h 36119 2010-10-06 14:10:03Z rdm $	// @(#)root/gui:$Id: TGListBox.h 48991 2013-03-28 15:25:11Z rdm $
	// Author: Fons Rademakers 12/01/98	// Author: Fons Rademakers 12/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 155	skipping to change at line 155

	class TGLineLBEntry : public TGTextLBEntry {	class TGLineLBEntry : public TGTextLBEntry {

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

	protected:	protected:
	UInt_t fLineWidth; // line width	UInt_t fLineWidth; // line width
	Style_t fLineStyle; // line style	Style_t fLineStyle; // line style

	UInt_t fLineLength; // line lenght	UInt_t fLineLength; // line length
	TGGC *fLineGC; // line graphics context	TGGC *fLineGC; // line graphics context

	virtual void DoRedraw();	virtual void DoRedraw();

	public:	public:
	TGLineLBEntry(const TGWindow p = 0, Int_t id = -1, const char str = 0,	TGLineLBEntry(const TGWindow p = 0, Int_t id = -1, const char str = 0,
	UInt_t w = 0, Style_t s = 0,	UInt_t w = 0, Style_t s = 0,
	UInt_t options = kHorizontalFrame,	UInt_t options = kHorizontalFrame,
	Pixel_t back = GetWhitePixel());	Pixel_t back = GetWhitePixel());
	virtual ~TGLineLBEntry();	virtual ~TGLineLBEntry();

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

	TGMdiMainFrame.h	TGMdiMainFrame.h

	// @(#)root/gui:$Id: TGMdiMainFrame.h 40531 2011-08-10 13:56:13Z bellenot $	// @(#)root/gui:$Id: TGMdiMainFrame.h 48991 2013-03-28 15:25:11Z rdm $
	// Author: Bertrand Bellenot 20/08/2004	// Author: Bertrand Bellenot 20/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 151	skipping to change at line 151

	friend class TGMdiFrame;	friend class TGMdiFrame;

	protected:	protected:
	enum {	enum {
	// the width of minimized windows, in "height" units	// the width of minimized windows, in "height" units
	kMinimizedWidth = 5	kMinimizedWidth = 5
	};	};

	Int_t fCurrentX, fCurrentY, fResizeMode; // current MDI chi ld XY position and resize mode	Int_t fCurrentX, fCurrentY, fResizeMode; // current MDI chi ld XY position and resize mode

	Int_t fArrangementMode; // MDI childs arra	Int_t fArrangementMode; // MDI children ar
	ngement mode	rangement mode
	TGFont fFontCurrent, fFontNotCurrent; // fonts for activ	TGFont fFontCurrent, fFontNotCurrent; // fonts for activ
	e and inactive MDI childs	e and inactive MDI children
	Pixel_t fBackCurrent, fForeCurrent; // back and fore c	Pixel_t fBackCurrent, fForeCurrent; // back and fore c
	olors for active MDI childs	olors for active MDI children
	Pixel_t fBackNotCurrent, fForeNotCurrent; // back and fore c	Pixel_t fBackNotCurrent, fForeNotCurrent; // back and fore c
	olors for inactive MDI childs	olors for inactive MDI children

	TGGC *fBoxGC; // GC used to draw resizing box (rectangle)	TGGC *fBoxGC; // GC used to draw resizing box (rectangle)

	Long_t fNumberOfFrames; // number of MDI c hild windows	Long_t fNumberOfFrames; // number of MDI c hild windows
	TGMdiMenuBar *fMenuBar; // menu bar	TGMdiMenuBar *fMenuBar; // menu bar
	TGFrame *fContainer; // MDI container	TGFrame *fContainer; // MDI container
	TGPopupMenu *fWinListMenu; // popup menu with list of MDI child windows	TGPopupMenu *fWinListMenu; // popup menu with list of MDI child windows
	TGMdiFrameList *fChildren; // list of MDI chi ld windows	TGMdiFrameList *fChildren; // list of MDI chi ld windows
	TGMdiFrameList *fCurrent; // current list of MDI child windows	TGMdiFrameList *fCurrent; // current list of MDI child windows


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

	TGPack.h	TGPack.h

	// @(#)root/eve:$Id: TGPack.h 29129 2009-06-22 09:39:20Z brun $	// @(#)root/eve:$Id: TGPack.h 48991 2013-03-28 15:25:11Z rdm $
	// 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. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 104	skipping to change at line 104

	void EqualizeFrames();	void EqualizeFrames();
	void HandleSplitterStart();	void HandleSplitterStart();
	void HandleSplitterResize(Int_t delta);	void HandleSplitterResize(Int_t delta);

	// ----------------------------------------------------------------	// ----------------------------------------------------------------

	Bool_t GetVertical() const { return fVertical; }	Bool_t GetVertical() const { return fVertical; }
	void SetVertical(Bool_t x);	void SetVertical(Bool_t x);


	// For now assume this is always true. Lenght of splitter = 4 pixels.	// For now assume this is always true. Length of splitter = 4 pixels.
	Bool_t GetUseSplitters() const { return fUseSplitters; }	Bool_t GetUseSplitters() const { return fUseSplitters; }
	void SetUseSplitters(Bool_t x) { fUseSplitters = x; }	void SetUseSplitters(Bool_t x) { fUseSplitters = x; }

	ClassDef(TGPack, 0); // Horizontal or vertical stack of frames.	ClassDef(TGPack, 0); // Horizontal or vertical stack of frames.
	};	};

	#endif	#endif

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

	TGText.h	TGText.h

	// @(#)root/gui:$Id: TGText.h 23115 2008-04-10 13:35:37Z rdm $	// @(#)root/gui:$Id: TGText.h 48991 2013-03-28 15:25:11Z rdm $
	// Author: Fons Rademakers 26/04/98	// Author: Fons Rademakers 26/04/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 39	skipping to change at line 39
	#ifndef ROOT_TGDimension	#ifndef ROOT_TGDimension
	#include "TGDimension.h"	#include "TGDimension.h"
	#endif	#endif

	class TGTextLine {	class TGTextLine {

	friend class TGText;	friend class TGText;

	protected:	protected:
	char *fString; // line of text	char *fString; // line of text

	ULong_t fLength; // lenght of line	ULong_t fLength; // length of line
	TGTextLine *fPrev; // previous line	TGTextLine *fPrev; // previous line
	TGTextLine *fNext; // next line	TGTextLine *fNext; // next line

	TGTextLine(const TGTextLine&);	TGTextLine(const TGTextLine&);
	TGTextLine& operator=(const TGTextLine&);	TGTextLine& operator=(const TGTextLine&);

	public:	public:
	TGTextLine();	TGTextLine();
	TGTextLine(TGTextLine *line);	TGTextLine(TGTextLine *line);
	TGTextLine(const char *string);	TGTextLine(const char *string);

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

	TGenCollectionStreamer.h	TGenCollectionStreamer.h

	// @(#)root/io:$Id: TGenCollectionStreamer.h 43271 2012-03-07 05:53:52Z pca nal $	// @(#)root/io:$Id: TGenCollectionStreamer.h 49000 2013-03-29 10:47:59Z 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 30	skipping to change at line 30
	//	//
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#include "TGenCollectionProxy.h"	#include "TGenCollectionProxy.h"
	#include "TCollectionProxyFactory.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, const TClass *onfileClass);
	void ReadPairFromMap(int nElements, TBuffer &b);	void ReadPairFromMap(int nElements, TBuffer &b);

	void ReadObjects(int nElements, TBuffer &b);	void ReadObjects(int nElements, TBuffer &b, const TClass *onfileClass);
	void ReadPrimitives(int nElements, TBuffer &b);	void ReadPrimitives(int nElements, TBuffer &b, const TClass *onfileClass
		);
	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);	// typedef void (TGenCollectionStreamer::ReadBufferConv_t)(TBuffer &b, v oid obj, const TClass *onFileClass);
	// ReadBufferConv_t fReadBufferConvFunc;	// ReadBufferConv_t fReadBufferConvFunc;


	typedef void (TGenCollectionStreamer::ReadBuffer_t)(TBuffer &b, void o bj);	typedef void (TGenCollectionStreamer::ReadBuffer_t)(TBuffer &b, void o bj, const TClass *onFileClass);
	ReadBuffer_t fReadBufferFunc;	ReadBuffer_t fReadBufferFunc;


	template <typename basictype> void ReadBufferVectorPrimitives(TBuffer &b	template <typename From, typename To> void ConvertBufferVectorPrimitives
	, void *obj);	(TBuffer &b, void *obj, Int_t nElements);
	void ReadBufferVectorPrimitivesFloat16(TBuffer &b, void *obj);	template <typename To> void ConvertBufferVectorPrimitivesFloat16(TBuffer
	void ReadBufferVectorPrimitivesDouble32(TBuffer &b, void *obj);	&b, void *obj, Int_t nElements);
	void ReadBufferDefault(TBuffer &b, void *obj);	template <typename To> void ConvertBufferVectorPrimitivesDouble32(TBuffe
	void ReadBufferGeneric(TBuffer &b, void *obj);	r &b, void *obj, Int_t nElements);
		template <typename To> void DispatchConvertBufferVectorPrimitives(TBuffe
		r &b, void obj, Int_t nElements, const TVirtualCollectionProxy onfileProx
		y);
		template <typename basictype> void ReadBufferVectorPrimitives(TBuffer &b
		, void obj, const TClass onFileClass);
		void ReadBufferVectorPrimitivesFloat16(TBuffer &b, void *obj, const TCla
		ss *onFileClass);
		void ReadBufferVectorPrimitivesDouble32(TBuffer &b, void *obj, const TCl
		ass *onFileClass);
		void ReadBufferDefault(TBuffer &b, void obj, const TClass onFileClass)
		;
		void ReadBufferGeneric(TBuffer &b, void obj, const TClass onFileClass)
		;

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

	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);

	skipping to change at line 96	skipping to change at line 100
	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 = T::resize;	fResize = T::resize;

	fCollect.call = T::collect;	fCollect = T::collect;
	fConstruct = T::construct;	fConstruct = T::construct;
	fDestruct = T::destruct;	fDestruct = T::destruct;
	fFeed = 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;

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

	TGeoMatrix.h	TGeoMatrix.h

	// @(#)root/geom:$Id: TGeoMatrix.h 40116 2011-07-04 12:00:32Z agheata $	// @(#)root/geom:$Id: TGeoMatrix.h 49273 2013-04-19 07:48:30Z agheata $
	// Author: Andrei Gheata 25/10/01	// Author: Andrei Gheata 25/10/01

	/*************************************************************************	/*************************************************************************
	* 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 45	skipping to change at line 45
	// / /	// / /
	// TGeoMatrix - base class for geometrical transformations. / /	// TGeoMatrix - base class for geometrical transformations. / /
	// / /	// / /
	/////////////////////////////////////////////////////////////////////////// /	/////////////////////////////////////////////////////////////////////////// /

	class TGeoMatrix : public TNamed	class TGeoMatrix : public TNamed
	{	{
	public:	public:
	enum EGeoTransfTypes {	enum EGeoTransfTypes {
	kGeoIdentity = 0,	kGeoIdentity = 0,

		kGeoShared = BIT(14),
	kGeoTranslation = BIT(17),	kGeoTranslation = BIT(17),
	kGeoRotation = BIT(18),	kGeoRotation = BIT(18),
	kGeoScale = BIT(19),	kGeoScale = BIT(19),
	kGeoReflection = BIT(20),	kGeoReflection = BIT(20),
	kGeoRegistered = BIT(21),	kGeoRegistered = BIT(21),
	kGeoSavePrimitive = BIT(22),	kGeoSavePrimitive = BIT(22),
	kGeoMatrixOwned = BIT(23),	kGeoMatrixOwned = BIT(23),
	kGeoCombiTrans = kGeoTranslation \| kGeoRotation,	kGeoCombiTrans = kGeoTranslation \| kGeoRotation,
	kGeoGenTrans = kGeoTranslation \| kGeoRotation \| kGeoScale	kGeoGenTrans = kGeoTranslation \| kGeoRotation \| kGeoScale
	};	};

	skipping to change at line 81	skipping to change at line 82
	#if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 4060 0	#if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 4060 0
	#pragma GCC diagnostic pop	#pragma GCC diagnostic pop
	#endif	#endif
	Bool_t operator ==(const TGeoMatrix &other) const;	Bool_t operator ==(const TGeoMatrix &other) const;

	Bool_t IsIdentity() const {return !TestBit(kGeoGenTrans );}	Bool_t IsIdentity() const {return !TestBit(kGeoGenTrans );}
	Bool_t IsTranslation() const {return TestBit(kGeoTranslati on);}	Bool_t IsTranslation() const {return TestBit(kGeoTranslati on);}
	Bool_t IsRotation() const {return TestBit(kGeoRotation) ;}	Bool_t IsRotation() const {return TestBit(kGeoRotation) ;}
	Bool_t IsReflection() const {return TestBit(kGeoReflectio n);}	Bool_t IsReflection() const {return TestBit(kGeoReflectio n);}
	Bool_t IsScale() const {return TestBit(kGeoScale);}	Bool_t IsScale() const {return TestBit(kGeoScale);}

		Bool_t IsShared() const {return TestBit(kGeoShared);}
	Bool_t IsCombi() const {return (TestBit(kGeoTranslat ion)	Bool_t IsCombi() const {return (TestBit(kGeoTranslat ion)
	&& TestBit(kGeoRotation));}	&& TestBit(kGeoRotation));}
	Bool_t IsGeneral() const {return (TestBit(kGeoTranslat ion)	Bool_t IsGeneral() const {return (TestBit(kGeoTranslat ion)
	&& TestBit(kGeoRotation) && TestBit(kGeoScale)) ;}	&& TestBit(kGeoRotation) && TestBit(kGeoScale)) ;}
	Bool_t IsRegistered() const {return TestBit(kGeoRegistere d);}	Bool_t IsRegistered() const {return TestBit(kGeoRegistere d);}
	Bool_t IsRotAboutZ() const;	Bool_t IsRotAboutZ() const;
	void GetHomogenousMatrix(Double_t *hmat) const;	void GetHomogenousMatrix(Double_t *hmat) const;
	char *GetPointerName() const;	char *GetPointerName() const;

	virtual Int_t GetByteCount() const;	virtual Int_t GetByteCount() const;

	skipping to change at line 115	skipping to change at line 117
	virtual void RotateY(Double_t) {}	virtual void RotateY(Double_t) {}
	virtual void RotateZ(Double_t) {}	virtual void RotateZ(Double_t) {}
	virtual void ReflectX(Bool_t leftside,Bool_t rotonly=kFALSE);	virtual void ReflectX(Bool_t leftside,Bool_t rotonly=kFALSE);
	virtual void ReflectY(Bool_t leftside,Bool_t rotonly=kFALSE);	virtual void ReflectY(Bool_t leftside,Bool_t rotonly=kFALSE);
	virtual void ReflectZ(Bool_t leftside,Bool_t rotonly=kFALSE);	virtual void ReflectZ(Bool_t leftside,Bool_t rotonly=kFALSE);
	virtual void RegisterYourself();	virtual void RegisterYourself();
	void SetDefaultName();	void SetDefaultName();
	virtual void SetDx(Double_t) {}	virtual void SetDx(Double_t) {}
	virtual void SetDy(Double_t) {}	virtual void SetDy(Double_t) {}
	virtual void SetDz(Double_t) {}	virtual void SetDz(Double_t) {}

		void SetShared(Bool_t flag=kTRUE) {SetBit(kGeoShared, fl ag);}

	ClassDef(TGeoMatrix, 1) // base geometrical transformati on class	ClassDef(TGeoMatrix, 1) // base geometrical transformati on class
	};	};

	/////////////////////////////////////////////////////////////////////////// /	/////////////////////////////////////////////////////////////////////////// /
	// / /	// / /
	// TGeoTranslation - class describing translations. A translation is / /	// TGeoTranslation - class describing translations. A translation is / /
	// basicaly an array of 3 doubles matching the positions 12, 13 / /	// basicaly an array of 3 doubles matching the positions 12, 13 / /
	// and 14 in the homogenous matrix description. / /	// and 14 in the homogenous matrix description. / /
	// / /	// / /

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

	TMethodArg.h	TMethodArg.h

	// @(#)root/meta:$Id: TMethodArg.h 25986 2008-10-28 08:39:44Z brun $	// @(#)root/meta:$Id: TMethodArg.h 48771 2013-02-28 19:49:49Z pcanal $
	// Author: Rene Brun 04/02/95	// Author: Rene Brun 04/02/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 51	skipping to change at line 51
	TFunction *fMethod; //pointer to the method or global func tion	TFunction *fMethod; //pointer to the method or global func tion
	TDataMember *fDataMember; //TDataMember pointed by this arg,to g et values and options from.	TDataMember *fDataMember; //TDataMember pointed by this arg,to g et values and options from.

	public:	public:
	TMethodArg(MethodArgInfo_t info = 0, TFunction method = 0);	TMethodArg(MethodArgInfo_t info = 0, TFunction method = 0);
	virtual ~TMethodArg();	virtual ~TMethodArg();
	const char *GetDefault() const;	const char *GetDefault() const;
	TFunction *GetMethod() const { return fMethod; }	TFunction *GetMethod() const { return fMethod; }
	const char *GetTypeName() const;	const char *GetTypeName() const;
	const char *GetFullTypeName() const;	const char *GetFullTypeName() const;

		std::string GetTypeNormalizedName() const;
	Long_t Property() const;	Long_t Property() const;

	TDataMember *GetDataMember() const;	TDataMember *GetDataMember() const;
	TList *GetOptions() const;	TList *GetOptions() const;

	ClassDef(TMethodArg,0) //Dictionary for a method argument	ClassDef(TMethodArg,0) //Dictionary for a method argument
	};	};

	#endif	#endif

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

	TObject.h	TObject.h

	// @(#)root/base:$Id: TObject.h 48256 2013-01-10 14:24:07Z axel $	// @(#)root/base:$Id: TObject.h 49056 2013-04-01 13:19:26Z pcanal $
	// Author: Rene Brun 26/12/94	// Author: Rene Brun 26/12/94

	/*************************************************************************	/*************************************************************************
	* 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. *
	*************************************************************************/	*************************************************************************/


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

	TPRegexp.h	TPRegexp.h

	// @(#)root/base:$Id: TPRegexp.h 26600 2008-12-02 18:56:10Z brun $	// @(#)root/base:$Id: TPRegexp.h 48662 2013-02-21 11:31:15Z rdm $
	// Author: Eddy Offermann 24/06/05	// Author: Eddy Offermann 24/06/05

	/*************************************************************************	/*************************************************************************
	* 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 55	skipping to change at line 55
	kPCRE_GLOBAL = 0x80000000,	kPCRE_GLOBAL = 0x80000000,
	kPCRE_OPTIMIZE = 0x40000000,	kPCRE_OPTIMIZE = 0x40000000,
	kPCRE_DEBUG_MSGS = 0x20000000,	kPCRE_DEBUG_MSGS = 0x20000000,
	kPCRE_INTMASK = 0x0FFF	kPCRE_INTMASK = 0x0FFF
	};	};

	TString fPattern;	TString fPattern;
	PCREPriv_t *fPriv;	PCREPriv_t *fPriv;
	UInt_t fPCREOpts;	UInt_t fPCREOpts;


		static Bool_t fgThrowAtCompileError;

	void Compile();	void Compile();
	void Optimize();	void Optimize();
	UInt_t ParseMods(const TString &mods) const;	UInt_t ParseMods(const TString &mods) const;
	Int_t ReplaceSubs(const TString &s, TString &final,	Int_t ReplaceSubs(const TString &s, TString &final,
	const TString &replacePattern,	const TString &replacePattern,
	Int_t *ovec, Int_t nmatch) const;	Int_t *ovec, Int_t nmatch) const;

	Int_t MatchInternal(const TString& s, Int_t start,	Int_t MatchInternal(const TString& s, Int_t start,
	Int_t nMaxMatch, TArrayI *pos=0);	Int_t nMaxMatch, TArrayI *pos=0);

	Int_t SubstituteInternal(TString &s, const TString &replace,	Int_t SubstituteInternal(TString &s, const TString &replace,
	Int_t start, Int_t nMaxMatch0,	Int_t start, Int_t nMaxMatch0,
	Bool_t doDollarSubst);	Bool_t doDollarSubst);

	public:	public:
	TPRegexp();	TPRegexp();
	TPRegexp(const TString &pat);	TPRegexp(const TString &pat);
	TPRegexp(const TPRegexp &p);	TPRegexp(const TPRegexp &p);
	virtual ~TPRegexp();	virtual ~TPRegexp();


		Bool_t IsValid() const;

	Int_t Match(const TString &s, const TString &mods="",	Int_t Match(const TString &s, const TString &mods="",
	Int_t start=0, Int_t nMaxMatch=10, TArrayI *pos=0);	Int_t start=0, Int_t nMaxMatch=10, TArrayI *pos=0);
	TObjArray *MatchS(const TString &s, const TString &mods="",	TObjArray *MatchS(const TString &s, const TString &mods="",
	Int_t start=0, Int_t nMaxMatch=10);	Int_t start=0, Int_t nMaxMatch=10);
	Bool_t MatchB(const TString &s, const TString &mods="",	Bool_t MatchB(const TString &s, const TString &mods="",
	Int_t start=0, Int_t nMaxMatch=10) {	Int_t start=0, Int_t nMaxMatch=10) {
	return (Match(s,mods,start,nMaxMatch) > 0); }	return (Match(s,mods,start,nMaxMatch) > 0); }
	Int_t Substitute(TString &s, const TString &replace,	Int_t Substitute(TString &s, const TString &replace,
	const TString &mods="", Int_t start=0,	const TString &mods="", Int_t start=0,
	Int_t nMatchMax=10);	Int_t nMatchMax=10);

	TString GetPattern() const { return fPattern; }	TString GetPattern() const { return fPattern; }
	TString GetModifiers() const;	TString GetModifiers() const;

	TPRegexp &operator=(const TPRegexp &p);	TPRegexp &operator=(const TPRegexp &p);


		static Bool_t GetThrowAtCompileError();
		static void SetThrowAtCompileError(Bool_t throwp);

	ClassDef(TPRegexp,0) // Perl Compatible Regular Expression Class	ClassDef(TPRegexp,0) // Perl Compatible Regular Expression Class
	};	};

	class TPMERegexp : protected TPRegexp {	class TPMERegexp : protected TPRegexp {

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

	protected:	protected:
	Int_t fNMaxMatches; // maximum number of matches	Int_t fNMaxMatches; // maximum number of matches

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

	TParameter.h	TParameter.h

	// @(#)root/base:$Id: TParameter.h 48256 2013-01-10 14:24:07Z axel $	// @(#)root/base:$Id: TParameter.h 49118 2013-04-08 08:49:34Z rdm $
	// Author: Maarten Ballintijn 21/06/2004	// Author: Maarten Ballintijn 21/06/2004

	/*************************************************************************	/*************************************************************************
	* 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 51	skipping to change at line 51
	#endif	#endif

	#ifndef ROOT_TROOT	#ifndef ROOT_TROOT
	#include "TROOT.h"	#include "TROOT.h"
	#endif	#endif

	template <class AParamType>	template <class AParamType>
	class TParameter : public TObject {	class TParameter : public TObject {

	public:	public:

	enum EStatusBits { kMultiply = BIT(16) }; // Use multiplication while me	// Defines options / status while merging:
	rging	enum EStatusBits { kMultiply = BIT(16), // Use multiplication
		kMax = BIT(17), // Take max value
		kMin = BIT(18), // Take min value
		kFirst = BIT(19), // Take the first value
		kLast = BIT(20), // Take the last value
		kIsConst = BIT(21) // Set if all values are eq
		ual
		};

	private:	private:
	TString fName;	TString fName;
	AParamType fVal;	AParamType fVal;


		void Reset() { ResetBit(kMultiply); ResetBit(kMax); ResetBit(kMin
		);
		ResetBit(kFirst); ResetBit(kLast); }

	public:	public:

	TParameter(): fVal() {}	TParameter(): fVal() { Reset(); SetBit(kIsConst); }
	TParameter(const char *name, const AParamType &val)	TParameter(const char *name, const AParamType &val)

	: fName(name), fVal(val) { ResetBit(kMultiply); }	: fName(name), fVal(val) { Reset(); SetBit(kIsConst);}
	TParameter(const char *name, const AParamType &val, char mergemode)	TParameter(const char *name, const AParamType &val, char mergemode)

	: fName(name), fVal(val) { SetMergeMode(mergemode); }	: fName(name), fVal(val) { SetMergeMode(mergemode); SetBit(kIs Const);}
	~TParameter() { }	~TParameter() { }

	const char *GetName() const { return fName; }	const char *GetName() const { return fName; }
	const AParamType &GetVal() const { return fVal; }	const AParamType &GetVal() const { return fVal; }

		Bool_t IsConst() const { return (TestBit(kIsConst) ? kTRUE : kFALSE); }
	void SetVal(const AParamType &val) { fVal = val; }	void SetVal(const AParamType &val) { fVal = val; }

	void SetMergeMode(char mergemode = '+') { ResetBit(kMultipl
	y);
	if (mergemode ==
	'*') SetBit(kMultiply); }


		// Merging modes:
		// '+' addition ('OR' for booleans) [default]
		// '*' multiplication ('AND' for booleans)
		// 'M' maximum ('OR' for booleans)
		// 'm' minimum ('AND' for booleans)
		// 'f' first value
		// 'l' last value
		void SetMergeMode(char mergemode = '+') {
		Reset();
		if (mergemode == '*') {
		SetBit(kMultiply);
		} else if (mergemode == 'M') {
		SetBit(kMax);
		} else if (mergemode == 'm') {
		SetBit(kMin);
		} else if (mergemode == 'f') {
		SetBit(kFirst);
		} else if (mergemode == 'l') {
		SetBit(kLast);
		}
		}
	virtual ULong_t Hash() const { return fName.Hash(); }	virtual ULong_t Hash() const { return fName.Hash(); }
	virtual Bool_t IsSortable() const { return kTRUE; }	virtual Bool_t IsSortable() const { return kTRUE; }
	virtual Int_t Compare(const TObject *obj) const {	virtual Int_t Compare(const TObject *obj) const {
	// Compare two TParameter objects. Returns 0 when equal, -1 when this is	// Compare two TParameter objects. Returns 0 when equal, -1 when this is
	// smaller and +1 when bigger (like strcmp).	// smaller and +1 when bigger (like strcmp).

	if (this == obj) return 0;	if (this == obj) return 0;
	return fName.CompareTo(obj->GetName());	return fName.CompareTo(obj->GetName());
	}	}


	skipping to change at line 107	skipping to change at line 137

	template <class AParamType>	template <class AParamType>
	inline Int_t TParameter<AParamType>::Merge(TCollection *in) {	inline Int_t TParameter<AParamType>::Merge(TCollection *in) {
	// Merge objects in the list.	// Merge objects in the list.
	// Returns the number of objects that were in the list.	// Returns the number of objects that were in the list.
	TIter nxo(in);	TIter nxo(in);
	Int_t n = 0;	Int_t n = 0;
	while (TObject *o = nxo()) {	while (TObject *o = nxo()) {
	TParameter<AParamType> c = dynamic_cast<TParameter<AParamType> >(o) ;	TParameter<AParamType> c = dynamic_cast<TParameter<AParamType> >(o) ;
	if (c) {	if (c) {

	if (TestBit(kMultiply))	// Check if constant
		if (fVal != c->GetVal()) ResetBit(kIsConst);
		if (TestBit(kMultiply)) {
		// Multiply
	fVal *= c->GetVal();	fVal *= c->GetVal();

	else	} else if (TestBit(kMax)) {
		// Take max
		if (c->GetVal() > fVal) fVal = c->GetVal();
		} else if (TestBit(kMin)) {
		// Take min
		if (c->GetVal() < fVal) fVal = c->GetVal();
		} else if (TestBit(kLast)) {
		// Take the last
		fVal = c->GetVal();
		} else if (!TestBit(kFirst)) {
		// Add, if not asked to take the first
	fVal += c->GetVal();	fVal += c->GetVal();

		}
	n++;	n++;
	}	}
	}	}

	return n;	return n;
	}	}

	// Specialization of Merge for Bool_t	// Specialization of Merge for Bool_t
	template <>	template <>
	inline Int_t TParameter<Bool_t>::Merge(TCollection *in)	inline Int_t TParameter<Bool_t>::Merge(TCollection *in)
	{	{
	// Merge bool objects in the list.	// Merge bool objects in the list.
	// Returns the number of objects that were in the list.	// Returns the number of objects that were in the list.
	TIter nxo(in);	TIter nxo(in);
	Int_t n = 0;	Int_t n = 0;
	while (TObject *o = nxo()) {	while (TObject *o = nxo()) {
	TParameter<Bool_t> c = dynamic_cast<TParameter<Bool_t> >(o);	TParameter<Bool_t> c = dynamic_cast<TParameter<Bool_t> >(o);
	if (c) {	if (c) {

	if (TestBit(TParameter::kMultiply))	// Check if constant
		if (fVal != (Bool_t) c->GetVal()) ResetBit(kIsConst);
		if (TestBit(TParameter::kMultiply) \|\| TestBit(kMin)) {
		// And
	fVal &= (Bool_t) c->GetVal();	fVal &= (Bool_t) c->GetVal();

	else	} else if (TestBit(kLast)) {
		// Take the last
		fVal = (Bool_t) c->GetVal();
		} else if (!TestBit(kFirst) \|\| TestBit(kMax)) {
		// Or
	fVal \|= (Bool_t) c->GetVal();	fVal \|= (Bool_t) c->GetVal();

		}
	n++;	n++;
	}	}
	}	}

	return n;	return n;
	}	}

	#endif	#endif

End of changes. 15 change blocks.
	14 lines changed or deleted	65 lines changed or added

	TProof.h	TProof.h

	// @(#)root/proof:$Id: TProof.h 48276 2013-01-12 11:38:52Z ganis $	// @(#)root/proof:$Id: TProof.h 48991 2013-03-28 15:25:11Z rdm $
	// Author: Fons Rademakers 13/02/97	// Author: Fons Rademakers 13/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 314	skipping to change at line 314

	Bool_t AreAllWorkersAssigned();	Bool_t AreAllWorkersAssigned();
	Bool_t AreAllWorkersMerged();	Bool_t AreAllWorkersMerged();

	void Deactivate() { fIsActive = kFALSE; }	void Deactivate() { fIsActive = kFALSE; }
	Bool_t IsActive() { return fIsActive; }	Bool_t IsActive() { return fIsActive; }

	ClassDef(TMergerInfo,0) // Basic info on merger, i.e. worker se rving as merger	ClassDef(TMergerInfo,0) // Basic info on merger, i.e. worker se rving as merger
	};	};


	// Small auxilliary class for merging progress notification	// Small auxiliary class for merging progress notification
	class TProofMergePrg {	class TProofMergePrg {
	private:	private:
	TString fExp;	TString fExp;
	Int_t fIdx;	Int_t fIdx;
	Int_t fNWrks;	Int_t fNWrks;
	Int_t fLastNWrks;	Int_t fLastNWrks;
	static char fgCr[4];	static char fgCr[4];
	public:	public:
	TProofMergePrg() : fExp(), fIdx(-1), fNWrks(-1), fLastNWrks(-1) { }	TProofMergePrg() : fExp(), fIdx(-1), fNWrks(-1), fLastNWrks(-1) { }


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

	TPython.h	TPython.h

	// @(#)root/pyroot:$Id: TPython.h 48108 2012-12-18 19:11:13Z wlav $	// @(#)root/pyroot:$Id: TPython.h 48878 2013-03-15 12:42:41Z wlav $
	#ifndef ROOT_TPython	#ifndef ROOT_TPython
	#define ROOT_TPython	#define ROOT_TPython

	/////////////////////////////////////////////////////////////////////////// ///	/////////////////////////////////////////////////////////////////////////// ///
	// //	// //
	// TPython //	// TPython //
	// //	// //
	// Access to the python interpreter and API onto PyROOT. //	// Access to the python interpreter and API onto PyROOT. //
	// //	// //
	/////////////////////////////////////////////////////////////////////////// ///	/////////////////////////////////////////////////////////////////////////// ///

	skipping to change at line 49	skipping to change at line 49
	// bind a ROOT object with, at the python side, the name "label"	// bind a ROOT object with, at the python side, the name "label"
	static Bool_t Bind( TObject* object, const char* label );	static Bool_t Bind( TObject* object, const char* label );

	// enter an interactive python session (exit with ^D)	// enter an interactive python session (exit with ^D)
	static void Prompt();	static void Prompt();

	// type verifiers for ObjectProxy	// type verifiers for ObjectProxy
	static Bool_t ObjectProxy_Check( PyObject* pyobject );	static Bool_t ObjectProxy_Check( PyObject* pyobject );
	static Bool_t ObjectProxy_CheckExact( PyObject* pyobject );	static Bool_t ObjectProxy_CheckExact( PyObject* pyobject );


		// type verifiers for MethodProxy
		static Bool_t MethodProxy_Check( PyObject* pyobject );
		static Bool_t MethodProxy_CheckExact( PyObject* pyobject );

	// object proxy to void* conversion	// object proxy to void* conversion
	static void* ObjectProxy_AsVoidPtr( PyObject* pyobject );	static void* ObjectProxy_AsVoidPtr( PyObject* pyobject );

	// void* to object proxy conversion, returns a new reference	// void* to object proxy conversion, returns a new reference
	static PyObject* ObjectProxy_FromVoidPtr(	static PyObject* ObjectProxy_FromVoidPtr(
	void* addr, const char* classname, Bool_t python_owns = kFALSE );	void* addr, const char* classname, Bool_t python_owns = kFALSE );

	virtual ~TPython() { }	virtual ~TPython() { }
	ClassDef(TPython,0) //Access to the python interpreter	ClassDef(TPython,0) //Access to the python interpreter
	};	};

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

	TQApplication.h	TQApplication.h

	// @(#)root/qtgsi:$Id: TQApplication.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/qtgsi:$Id: TQApplication.h 48991 2013-03-28 15:25:11Z rdm $
	// Author: Denis Bertini, M. Al-Turany 01/11/2000	// Author: Denis Bertini, M. Al-Turany 01/11/2000

	/*************************************************************************	/*************************************************************************
	* 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_TQApplication	#ifndef ROOT_TQApplication
	#define ROOT_TQApplication	#define ROOT_TQApplication

	/////////////////////////////////////////////////////////////////////////// ///////	/////////////////////////////////////////////////////////////////////////// ///////
	//	//
	// TQApplication	// TQApplication
	//	//

	// This class creates ROOT environement that will	// This class creates ROOT environment that will
	// interface with the Qt windowing system eventloop and eventhandlers.	// interface with the Qt windowing system eventloop and eventhandlers.
	// This class will be instantiated once (singleton) in a main()	// This class will be instantiated once (singleton) in a main()
	// program.	// program.
	//	//
	/////////////////////////////////////////////////////////////////////////// ///////	/////////////////////////////////////////////////////////////////////////// ///////

	#ifndef ROOT_TApplication	#ifndef ROOT_TApplication
	#include "TApplication.h"	#include "TApplication.h"
	#endif	#endif


	skipping to change at line 42	skipping to change at line 42
	private:	private:
	Bool_t fCustomized; // flag for customized canvas implimentation	Bool_t fCustomized; // flag for customized canvas implimentation

	public:	public:
	TQApplication();	TQApplication();
	TQApplication(const char appClassName, int argc, char *argv, void op tions = 0, int numOptions = 0);	TQApplication(const char appClassName, int argc, char *argv, void op tions = 0, int numOptions = 0);
	virtual ~TQApplication();	virtual ~TQApplication();
	virtual void LoadGraphicsLibs();	virtual void LoadGraphicsLibs();
	void SetCustomized();	void SetCustomized();


	ClassDef(TQApplication,0) //creates ROOT environement with the Qt window ing system	ClassDef(TQApplication,0) //creates ROOT environment with the Qt windowi ng system
	};	};

	#endif	#endif

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

	TQRootApplication.h	TQRootApplication.h

	// @(#)root/qtgsi:$Id: TQRootApplication.h 32344 2010-02-15 16:15:57Z belle not $	// @(#)root/qtgsi:$Id: TQRootApplication.h 48991 2013-03-28 15:25:11Z rdm $
	// Author: Denis Bertini, M. AL-Turany 01/11/2000	// Author: Denis Bertini, M. AL-Turany 01/11/2000

	/*************************************************************************	/*************************************************************************
	* 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_TQRootApplication	#ifndef ROOT_TQRootApplication
	#define ROOT_TQRootApplication	#define ROOT_TQRootApplication

	//////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////
	//	//
	// TQRootApplication	// TQRootApplication
	//	//

	// This class creates Qt environement that will	// This class creates Qt environment that will
	// interface with the ROOT windowing system eventloop and eventhandlers,	// interface with the ROOT windowing system eventloop and eventhandlers,
	// via a polling mechanism.	// via a polling mechanism.
	//	//
	///////////////////////////////////////////////////////////////////////	///////////////////////////////////////////////////////////////////////

	#ifndef __CINT__	#ifndef __CINT__
	#include "qapplication.h"	#include "qapplication.h"
	#include "qobject.h"	#include "qobject.h"
	#include "qtimer.h"	#include "qtimer.h"
	#endif	#endif

	skipping to change at line 61	skipping to change at line 61

	TQRootApplication(int &argc, char **argv,int poll=0);	TQRootApplication(int &argc, char **argv,int poll=0);
	~TQRootApplication();	~TQRootApplication();
	void SetDebugOn(){ fgDebug=kTRUE; }	void SetDebugOn(){ fgDebug=kTRUE; }
	void SetWarningOn(){ fgWarning=kTRUE;}	void SetWarningOn(){ fgWarning=kTRUE;}
	public slots:	public slots:
	void Execute();	void Execute();
	void Quit();	void Quit();

	public:	public:

	ClassDef(TQRootApplication,1) //creates Qt environement interface with the ROOT windowing system	ClassDef(TQRootApplication,1) //creates Qt environment interface with t he ROOT windowing system
	};	};

	#endif	#endif

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

	TRemoteObject.h	TRemoteObject.h

	// @(#)root/base:$Id: TRemoteObject.h 20877 2007-11-19 11:17:07Z rdm $	// @(#)root/base:$Id: TRemoteObject.h 48991 2013-03-28 15:25:11Z rdm $
	// Author: Bertrand Bellenot 19/06/2007	// Author: Bertrand Bellenot 19/06/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_TObjectRemote	#ifndef ROOT_TObjectRemote
	#define ROOT_TObjectRemote	#define ROOT_TObjectRemote

	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// //	// //
	// TRemoteObject //	// TRemoteObject //
	// //	// //
	// The TRemoteObject class provides protocol for browsing ROOT objects //	// The TRemoteObject class provides protocol for browsing ROOT objects //
	// from a remote ROOT session. //	// from a remote ROOT session. //

	// It contains informations on the real remote object as: //	// It contains information on the real remote object as: //
	// - Object Properties (i.e. file stat if the object is a TSystemFile) //	// - Object Properties (i.e. file stat if the object is a TSystemFile) //
	// - Object Name //	// - Object Name //
	// - Class Name //	// - Class Name //
	// - TKey Object Name (if the remote object is a TKey) //	// - TKey Object Name (if the remote object is a TKey) //
	// - TKey Class Name (if the remote object is a TKey) //	// - TKey Class Name (if the remote object is a TKey) //
	// - Remote object address //	// - Remote object address //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TSystemDirectory	#ifndef ROOT_TSystemDirectory

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

	TS3WebFile.h	TS3WebFile.h

	skipping to change at line 40	skipping to change at line 40
	// request, an 'Access Key Id' and a 'Secret Access Key' need to be //	// request, an 'Access Key Id' and a 'Secret Access Key' need to be //
	// known. These keys are used by the S3 servers to identify the client //	// known. These keys are used by the S3 servers to identify the client //
	// and to authenticate the request as genuine. //	// and to authenticate the request as genuine. //
	// //	// //
	// As an end user, you must know the Access Key and Secret Access Key //	// As an end user, you must know the Access Key and Secret Access Key //
	// in order to access each S3 file. They are provided to you by your S3 //	// in order to access each S3 file. They are provided to you by your S3 //
	// service provider. Those two keys can be provided to ROOT when //	// service provider. Those two keys can be provided to ROOT when //
	// initializing an object of this class by two means: //	// initializing an object of this class by two means: //
	// a) by using the environmental variables S3_ACCESS_KEY and //	// a) by using the environmental variables S3_ACCESS_KEY and //
	// S3_SECRET_KEY, or //	// S3_SECRET_KEY, or //

	// b) by specifying them when opening each file. //	// b) by specifying them as an argument when opening each file. //
	// //	// //
	// The first method is convenient if all the S3 files you want to //	// The first method is convenient if all the S3 files you want to //
	// access are hosted by a single provider. The second one is more //	// access are hosted by a single provider. The second one is more //
	// flexible as it allows you to specify which credentials to use //	// flexible as it allows you to specify which credentials to use //
	// on a per-file basis. See the documentation of the constructor of //	// on a per-file basis. See the documentation of the constructor of //
	// this class for details on the syntax. //	// this class for details on the syntax. //
	// //	// //
	// For generating and signing the HTTP request, this class uses //	// For generating and signing the HTTP request, this class uses //

	// THTTPMessage. //	// TS3HTTPRequest. //
	// //	// //
	// For more information on the details of S3 protocol please refer to: //	// For more information on the details of S3 protocol please refer to: //
	// "Amazon Simple Storage Service Developer Guide": //	// "Amazon Simple Storage Service Developer Guide": //
	// http://docs.amazonwebservices.com/AmazonS3/latest/dev/Welcome.html //	// http://docs.amazonwebservices.com/AmazonS3/latest/dev/Welcome.html //
	// //	// //
	// "Amazon Simple Storage Service REST API Reference" //	// "Amazon Simple Storage Service REST API Reference" //
	// http://docs.amazonwebservices.com/AmazonS3/latest/API/APIRest.html //	// http://docs.amazonwebservices.com/AmazonS3/latest/API/APIRest.html //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TWebFile	#ifndef ROOT_TWebFile

	skipping to change at line 71	skipping to change at line 71
	#endif	#endif

	#ifndef ROOT_TUrl	#ifndef ROOT_TUrl
	#include "TUrl.h"	#include "TUrl.h"
	#endif	#endif

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


		#ifndef ROOT_TS3HTTPRequest
		#include "TS3HTTPRequest.h"
		#endif

	class TS3WebFile: public TWebFile {	class TS3WebFile: public TWebFile {

	private:	private:
	TS3WebFile();	TS3WebFile();

	Bool_t ParseOptions(const TString& options);	Bool_t ParseOptions(Option_t* options, TString& accessKey, TString& secr
	Bool_t SetCredentialsFromEnv(const char* accessKeyEnv, const char* secre	etKey);
	tKeyEnv);	Bool_t GetCredentialsFromEnv(const char* accessKeyEnv, const char* secre
		tKeyEnv,
		TString& outAccessKey, TString& outSecretKe
		y);

	protected:	protected:
	// Super-class methods extended by this class	// Super-class methods extended by this class
	virtual Int_t GetHead();	virtual Int_t GetHead();
	virtual void SetMsgReadBuffer10(const char* redirectLocation = 0, Bool_t tempRedirect = kFALSE);	virtual void SetMsgReadBuffer10(const char* redirectLocation = 0, Bool_t tempRedirect = kFALSE);
	virtual void ProcessHttpHeader(const TString& headerLine);	virtual void ProcessHttpHeader(const TString& headerLine);

	// Modifiers of data members (to be used mainly by subclasses)	// Modifiers of data members (to be used mainly by subclasses)

	void SetAccessKey(const TString& accessKey) { fAccessKey = accessKey; }	void SetAccessKey(const TString& accessKey) { fS3Request.SetAccessKey(ac
	void SetSecretKey(const TString& secretKey) { fSecretKey = secretKey; }	cessKey); }
		void SetSecretKey(const TString& secretKey) { fS3Request.SetSecretKey(se
		cretKey); }

	// Data members	// Data members

	static const TString fgAuthPrefix; // Authentication prefix	TS3HTTPRequest fS3Request; // S3 HTTP request
	TString fAccessKey; // Access key ID	Bool_t fUseMultiRange; // Is the S3 server capable of serving m
	TString fSecretKey; // Secret access key	ultirange requests?
	TString fBucket; // Bucket name
	TString fObjectKey; // S3 object key (i.e. the file path within the
	bucket)
	Bool_t fUseMultiRange; // Is the S3 server capable of serving multiran
	ge requests?

	public:	public:
	// Constructors & Destructor	// Constructors & Destructor
	TS3WebFile(const char* url, Option_t* options="");	TS3WebFile(const char* url, Option_t* options="");
	virtual ~TS3WebFile() {}	virtual ~TS3WebFile() {}

	// Selectors	// Selectors

	const TString& GetAuthPrefix() const { return fgAuthPrefix; }	const TString& GetAccessKey() const { return fS3Request.GetAccessKey();
	const TString& GetAccessKey() const { return fAccessKey; }	}
	const TString& GetSecretKey() const { return fSecretKey; }	const TString& GetSecretKey() const { return fS3Request.GetSecretKey();
		}
		const TString& GetBucket() const { return fS3Request.GetBucket(); }
		const TString& GetObjectKey() const { return fS3Request.GetObjectKey();
		}
	const TUrl& GetUrl() const { return fUrl; }	const TUrl& GetUrl() const { return fUrl; }

	const TString& GetBucket() const { return fBucket; }
	const TString& GetObjectKey() const { return fObjectKey; }

	// Modifiers	// Modifiers
	virtual Bool_t ReadBuffers(char* buf, Long64_t* pos, Int_t* len, In t_t nbuf);	virtual Bool_t ReadBuffers(char* buf, Long64_t* pos, Int_t* len, In t_t nbuf);

	ClassDef(TS3WebFile, 0) // Read a ROOT file from a S3 server	ClassDef(TS3WebFile, 0) // Read a ROOT file from a S3 server
	};	};

	#endif // ROOT_TS3WebFile	#endif // ROOT_TS3WebFile

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

	TVirtualGL.h	TVirtualGL.h

	// @(#)root/base:$Id: TVirtualGL.h 20877 2007-11-19 11:17:07Z rdm $	// @(#)root/base:$Id: TVirtualGL.h 48649 2013-02-20 08:49:29Z tpochep $
	// Author: Valery Fine(fine@vxcern.cern.ch) 05/03/97	// Author: Valery Fine(fine@vxcern.cern.ch) 05/03/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 130	skipping to change at line 130

	static TGLManager *&Instance();	static TGLManager *&Instance();

	private:	private:
	TGLManager(const TGLManager &);	TGLManager(const TGLManager &);
	TGLManager &operator = (const TGLManager &);	TGLManager &operator = (const TGLManager &);

	ClassDef(TGLManager, 0)// Interface for OpenGL manager	ClassDef(TGLManager, 0)// Interface for OpenGL manager
	};	};


		namespace Rgl {

		//I would prefer to use C++11's strong typed enums insted, but ...
		enum EFormatOptions
		{
		kNone = 0,
		kDoubleBuffer = 1,
		kDepth = 2,
		kAccum = 4,
		kStencil = 8,
		kStereo = 16,
		kMultiSample = 32
		};

		}

	class TGLContext;	class TGLContext;
	class TGLFormat;	class TGLFormat;

	class TGLPaintDevice {	class TGLPaintDevice {
	friend class TGLContext;	friend class TGLContext;
	public:	public:
	virtual ~TGLPaintDevice(){}	virtual ~TGLPaintDevice(){}
	virtual Bool_t MakeCurrent() = 0;	virtual Bool_t MakeCurrent() = 0;
	virtual void SwapBuffers() = 0;	virtual void SwapBuffers() = 0;
	virtual const TGLFormat *GetPixelFormat()const = 0;	virtual const TGLFormat *GetPixelFormat()const = 0;

End of changes. 2 change blocks.
	1 lines changed or deleted	17 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/

	BitReproducible.h	BitReproducible.h

	// @(#)root/mathcore:$Id: BitReproducible.h 22516 2008-03-07 15:14:26Z mone ta $	// @(#)root/mathcore:$Id: BitReproducible.h 48991 2013-03-28 15:25:11Z rdm $
	// Authors: W. Brown, M. Fischler, L. Moneta 2005	// Authors: W. Brown, M. Fischler, L. Moneta 2005

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2005 , LCG / FNAL ROOT MathLib Team *	* Copyright (c) 2005 , LCG / FNAL ROOT MathLib Team *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for class LorentzVector	// Header file for class LorentzVector
	//	//
	// Created by: fischler at Mon Jun 25 2005	// Created by: fischler at Mon Jun 25 2005
	//	//

	// Last update: $Id: BitReproducible.h 22516 2008-03-07 15:14:26Z moneta $	// Last update: $Id: BitReproducible.h 48991 2013-03-28 15:25:11Z rdm $
	//	//
	#ifndef ROOT_Math_GenVector_BitReproducible	#ifndef ROOT_Math_GenVector_BitReproducible
	#define ROOT_Math_GenVector_BitReproducible 1	#define ROOT_Math_GenVector_BitReproducible 1

	#if defined(__alpha)	#if defined(__alpha)
	#ifndef __USE_STD_IOSTREAM	#ifndef __USE_STD_IOSTREAM
	#define __USE_STD_IOSTREAM	#define __USE_STD_IOSTREAM
	#endif	#endif
	#endif	#endif


	skipping to change at line 51	skipping to change at line 51
	const char* what() const throw() { return fMsg.c_str(); }	const char* what() const throw() { return fMsg.c_str(); }
	private:	private:
	std::string fMsg;	std::string fMsg;
	}; // DoubConvException	}; // DoubConvException

	class BitReproducible {	class BitReproducible {
	public:	public:

	// dto2longs(d, i1, i2) returns (in i1 and i2) two unsigned ints	// dto2longs(d, i1, i2) returns (in i1 and i2) two unsigned ints
	// representation of its double input. This is byte-ordering	// representation of its double input. This is byte-ordering

	// independant, and depends for complete portability ONLY on adherance	// independent, and depends for complete portability ONLY on adherance
	// to the IEEE 754 standard for 64-bit floating point representation.	// to the IEEE 754 standard for 64-bit floating point representation.
	// The first unsigned int contains the high-order bits in IEEE; thus	// The first unsigned int contains the high-order bits in IEEE; thus
	// 1.0 will always be 0x3FF00000, 00000000	// 1.0 will always be 0x3FF00000, 00000000
	static void Dto2longs(double d, unsigned int & i1, unsigned int & i2);	static void Dto2longs(double d, unsigned int & i1, unsigned int & i2);

	// longs2double (i1,i2) returns a double containing the value represented by	// longs2double (i1,i2) returns a double containing the value represented by
	// its input, which must be a 2 unsigned ints.	// its input, which must be a 2 unsigned ints.
	// The input is taken to be the representation according to	// The input is taken to be the representation according to
	// the IEEE 754 standard for a 64-bit floating point number, whose value	// the IEEE 754 standard for a 64-bit floating point number, whose value
	// is returned as a double. The byte-ordering of the double result is,	// is returned as a double. The byte-ordering of the double result is,
	// of course, tailored to the proper byte-ordering for the system.	// of course, tailored to the proper byte-ordering for the system.
	static double Longs2double (unsigned int i1, unsigned int i2);	static double Longs2double (unsigned int i1, unsigned int i2);

	// dtox(d) returns a 16-character string containing the (zero-filled) hex	// dtox(d) returns a 16-character string containing the (zero-filled) hex
	// representation of its double input. This is byte-ordering	// representation of its double input. This is byte-ordering

	// independant, and depends for complete portability ONLY on adherance	// independent, and depends for complete portability ONLY on adherance
	// to the IEEE 754 standard for 64-bit floating point representation.	// to the IEEE 754 standard for 64-bit floating point representation.
	static std::string D2x(double d);	static std::string D2x(double d);

	static void Output ( std::ostream & os, double d ) {	static void Output ( std::ostream & os, double d ) {
	unsigned int i1, i2;	unsigned int i1, i2;
	Dto2longs(d, i1, i2);	Dto2longs(d, i1, i2);
	os << " " << i1 << " " << i2;	os << " " << i1 << " " << i2;
	}	}

	static void Input ( std::istream & is, double & d ) {	static void Input ( std::istream & is, double & d ) {

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

	DecisionTreeNode.h	DecisionTreeNode.h

	// @(#)root/tmva $Id: DecisionTreeNode.h 40005 2011-06-27 15:29:10Z stelzer $	// @(#)root/tmva $Id: DecisionTreeNode.h 48991 2013-03-28 15:25:11Z rdm $
	// 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 235	skipping to change at line 235

	// return the sum of unweighted signal weights in the node	// return the sum of unweighted signal weights in the node
	Float_t GetNSigEvents_unweighted( void ) const { return fTrainInfo-> fNSigEvents_unweighted; }	Float_t GetNSigEvents_unweighted( void ) const { return fTrainInfo-> fNSigEvents_unweighted; }

	// return the sum of unweighted backgr weights in the node	// return the sum of unweighted backgr weights in the node
	Float_t GetNBkgEvents_unweighted( void ) const { return fTrainInfo-> fNBkgEvents_unweighted; }	Float_t GetNBkgEvents_unweighted( void ) const { return fTrainInfo-> fNBkgEvents_unweighted; }

	// return the number of unweighted events that entered the node (dur ing training)	// return the number of unweighted events that entered the node (dur ing training)
	Float_t GetNEvents_unweighted( void ) const { return fTrainInfo->fNE vents_unweighted; }	Float_t GetNEvents_unweighted( void ) const { return fTrainInfo->fNE vents_unweighted; }


	// set the choosen index, measure of "purity" (separation between S a nd B) AT this node	// set the chosen index, measure of "purity" (separation between S an d B) AT this node
	void SetSeparationIndex( Float_t sep ){ fTrainInfo->fSeparationIndex =sep ; }	void SetSeparationIndex( Float_t sep ){ fTrainInfo->fSeparationIndex =sep ; }
	// return the separation index AT this node	// return the separation index AT this node
	Float_t GetSeparationIndex( void ) const { return fTrainInfo->fSepar ationIndex; }	Float_t GetSeparationIndex( void ) const { return fTrainInfo->fSepar ationIndex; }

	// set the separation, or information gained BY this nodes selection	// set the separation, or information gained BY this nodes selection
	void SetSeparationGain( Float_t sep ){ fTrainInfo->fSeparationGain =s ep ; }	void SetSeparationGain( Float_t sep ){ fTrainInfo->fSeparationGain =s ep ; }
	// return the gain in separation obtained by this nodes selection	// return the gain in separation obtained by this nodes selection
	Float_t GetSeparationGain( void ) const { return fTrainInfo->fSepara tionGain; }	Float_t GetSeparationGain( void ) const { return fTrainInfo->fSepara tionGain; }

	// printout of the node	// printout of the node

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

	GSLMinimizer1D.h	GSLMinimizer1D.h

	// @(#)root/mathmore:$Id: GSLMinimizer1D.h 32583 2010-03-12 09:57:42Z monet a $	// @(#)root/mathmore:$Id: GSLMinimizer1D.h 48991 2013-03-28 15:25:11Z rdm $
	// Author: L. Moneta, A. Zsenei 08/2005	// Author: L. Moneta, A. Zsenei 08/2005
	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2004 moneta, CERN/PH-SFT *	* Copyright (c) 2004 moneta, 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 72	skipping to change at line 72

	//_________________________________________________________________________ _____________	//_________________________________________________________________________ _____________
	/**	/**

	Minimizer for arbitrary one dimensional functions.	Minimizer for arbitrary one dimensional functions.

	Implemented using GSL, for detailed description see:	Implemented using GSL, for detailed description see:
	<A HREF="http://www.gnu.org/software/gsl/manual/html_node/One-dimensional-M inimization.html">GSL online doc</A>	<A HREF="http://www.gnu.org/software/gsl/manual/html_node/One-dimensional-M inimization.html">GSL online doc</A>

	The algorithms uspported are only bracketing algorithm which do not use der ivatives information.	The algorithms uspported are only bracketing algorithm which do not use der ivatives information.

	The algorithms which can be choosen at construction time are GOLDENSECTION , whic is the simplest method	The algorithms which can be chosen at construction time are GOLDENSECTION, whic is the simplest method
	but the slowest and BRENT (the default one) which combines the golden secti on with a parabolic interpolation.	but the slowest and BRENT (the default one) which combines the golden secti on with a parabolic interpolation.

	This class does not support copying	This class does not support copying
	@ingroup Min1D	@ingroup Min1D
	*/	*/

	class GSLMinimizer1D: public IMinimizer1D {	class GSLMinimizer1D: public IMinimizer1D {

	public:	public:


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

	GSLRootFinder.h	GSLRootFinder.h

	// @(#)root/mathmore:$Id: GSLRootFinder.h 32583 2010-03-12 09:57:42Z moneta $	// @(#)root/mathmore:$Id: GSLRootFinder.h 48991 2013-03-28 15:25:11Z rdm $
	// 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 102	skipping to change at line 102
	}	}
	#endif	#endif

	bool SetFunction( const IGenFunction & f, double xlow, double xup);	bool SetFunction( const IGenFunction & f, double xlow, double xup);

	typedef double ( * GSLFuncPointer ) ( double, void *);	typedef double ( * GSLFuncPointer ) ( double, void *);
	bool SetFunction( GSLFuncPointer f, void * params, double xlow, double xup);	bool SetFunction( GSLFuncPointer f, void * params, double xlow, double xup);

	using IRootFinderMethod::SetFunction;	using IRootFinderMethod::SetFunction;


	// iterate to find ROOTS return GSL_CONTINUE if iteration was succesful l or another error	// iterate to find ROOTS return GSL_CONTINUE if iteration was successfu l or another error
	int Iterate();	int Iterate();

	double Root() const;	double Root() const;

	//double XLower() const;	//double XLower() const;

	//double XUpper() const;	//double XUpper() const;

	/// Find the root	/// Find the root
	bool Solve( int maxIter = 100, double absTol = 1E-8, double relTol = 1E -10);	bool Solve( int maxIter = 100, double absTol = 1E-8, double relTol = 1E -10);

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

	GSLRootFinderDeriv.h	GSLRootFinderDeriv.h

	// @(#)root/mathmore:$Id: GSLRootFinderDeriv.h 32583 2010-03-12 09:57:42Z m oneta $	// @(#)root/mathmore:$Id: GSLRootFinderDeriv.h 48991 2013-03-28 15:25:11Z r dm $
	// 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 109	skipping to change at line 109
	const void * p = &f;	const void * p = &f;
	return SetFunction( &GSLFunctionAdapter<IGradFunction>::F, &GSLFunct ionAdapter<IGradFunction>::Df, &GSLFunctionAdapter<IGradFunction>::Fdf, con st_cast<void *>(p), xstart );	return SetFunction( &GSLFunctionAdapter<IGradFunction>::F, &GSLFunct ionAdapter<IGradFunction>::Df, &GSLFunctionAdapter<IGradFunction>::Fdf, con st_cast<void *>(p), xstart );
	}	}

	typedef double ( * GSLFuncPointer ) ( double, void *);	typedef double ( * GSLFuncPointer ) ( double, void *);
	typedef void ( * GSLFdFPointer ) ( double, void , double , double *);	typedef void ( * GSLFdFPointer ) ( double, void , double , double *);
	bool SetFunction( GSLFuncPointer f, GSLFuncPointer df, GSLFdFPointer fdf , void * p, double Root );	bool SetFunction( GSLFuncPointer f, GSLFuncPointer df, GSLFdFPointer fdf , void * p, double Root );

	using IRootFinderMethod::SetFunction;	using IRootFinderMethod::SetFunction;


	/// iterate (return GSL_SUCCESS in case of succesfull iteration)	/// iterate (return GSL_SUCCESS in case of successful iteration)
	int Iterate();	int Iterate();

	double Root() const;	double Root() const;

	/// Find the root (return false if failed)	/// Find the root (return false if failed)
	bool Solve( int maxIter = 100, double absTol = 1E-8, double relTol = 1E- 10);	bool Solve( int maxIter = 100, double absTol = 1E-8, double relTol = 1E- 10);

	/// Return number of iterations	/// Return number of iterations
	int Iterations() const {	int Iterations() const {
	return fIter;	return fIter;

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

	GSLSimAnnealing.h	GSLSimAnnealing.h

	// @(#)root/mathmore:$Id: GSLSimAnnealing.h 21553 2007-12-21 10:55:46Z mone ta $	// @(#)root/mathmore:$Id: GSLSimAnnealing.h 48991 2013-03-28 15:25:11Z rdm $
	// Author: L. Moneta Thu Jan 25 11:13:48 2007	// Author: L. Moneta Thu Jan 25 11:13:48 2007

	/**********************************************************************	/**********************************************************************
	* *	* *
	* 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 68	skipping to change at line 68
	/**	/**
	construct from an interface of a multi-dimensional function	construct from an interface of a multi-dimensional function
	Use optionally a scale factor (for each coordinate) which can be use d to scale the step sizes	Use optionally a scale factor (for each coordinate) which can be use d to scale the step sizes
	(this is used for example by the minimization algorithm)	(this is used for example by the minimization algorithm)
	*/	*/
	GSLSimAnFunc(const ROOT::Math::IMultiGenFunction & func, const double * x, const double * scale);	GSLSimAnFunc(const ROOT::Math::IMultiGenFunction & func, const double * x, const double * scale);

	protected:	protected:

	/**	/**

	derived classes might need to re-define completly the class	derived classes might need to re-define completely the class
	*/	*/
	GSLSimAnFunc() :	GSLSimAnFunc() :
	fFunc(0)	fFunc(0)
	{}	{}

	public:	public:

	/// virtual distructor (no operations)	/// virtual distructor (no operations)
	virtual ~GSLSimAnFunc() { } //	virtual ~GSLSimAnFunc() { } //


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

	Interpolator.h	Interpolator.h

	// @(#)root/mathmore:$Id: Interpolator.h 24403 2008-06-20 08:31:10Z moneta $	// @(#)root/mathmore:$Id: Interpolator.h 48991 2013-03-28 15:25:11Z rdm $
	// 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 75	skipping to change at line 75
	/**	/**
	Constructs an interpolator class from number of data points and with Interpolation::Type type.	Constructs an interpolator class from number of data points and with Interpolation::Type type.
	The data can be set later on with the SetData method.	The data can be set later on with the SetData method.
	In case the data size is not known, better using the default of zero or the next constructor later on.	In case the data size is not known, better using the default of zero or the next constructor later on.
	The defult interpolation type is Cubic spline	The defult interpolation type is Cubic spline
	*/	*/
	Interpolator(unsigned int ndata = 0, Interpolation::Type type = Interpol ation::kCSPLINE);	Interpolator(unsigned int ndata = 0, Interpolation::Type type = Interpol ation::kCSPLINE);

	/**	/**
	Constructs an interpolator class from vector of data points \f$ (x_i, y_i )\f$ and with Interpolation::Type type.	Constructs an interpolator class from vector of data points \f$ (x_i, y_i )\f$ and with Interpolation::Type type.

	The method will compute a continous interpolating function \f$ y(x) \ f$ such that \f$ y_i = y ( x_i )\f$.	The method will compute a continuous interpolating function \f$ y(x) \f$ such that \f$ y_i = y ( x_i )\f$.
	The defult interpolation type is Cubic spline	The defult interpolation type is Cubic spline
	*/	*/
	Interpolator(const std::vector<double> & x, const std::vector<double> & y, Interpolation::Type type = Interpolation::kCSPLINE);	Interpolator(const std::vector<double> & x, const std::vector<double> & y, Interpolation::Type type = Interpolation::kCSPLINE);

	virtual ~Interpolator();	virtual ~Interpolator();

	private:	private:
	// usually copying is non trivial, so we make this unaccessible	// usually copying is non trivial, so we make this unaccessible
	Interpolator(const Interpolator &);	Interpolator(const Interpolator &);
	Interpolator & operator = (const Interpolator &);	Interpolator & operator = (const Interpolator &);

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

	Measurement.h	Measurement.h

	// @(#)root/roostats:$Id: Measurement.h 47093 2012-11-07 10:30:12Z moneta $	// @(#)root/roostats:$Id: Measurement.h 49255 2013-04-16 19:09:01Z pcanal $
	// Author: George Lewis, Kyle Cranmer	// Author: George Lewis, Kyle Cranmer
	/*************************************************************************	/*************************************************************************
	* 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 HISTFACTORY_MEASUREMENT_H	#ifndef HISTFACTORY_MEASUREMENT_H

	skipping to change at line 139	skipping to change at line 139
	std::vector< RooStats::HistFactory::Asimov > fAsimovDatasets;	std::vector< RooStats::HistFactory::Asimov > fAsimovDatasets;

	// List of Alternate constraint terms	// List of Alternate constraint terms
	std::map< std::string, double > fGammaSyst;	std::map< std::string, double > fGammaSyst;
	std::map< std::string, double > fUniformSyst;	std::map< std::string, double > fUniformSyst;
	std::map< std::string, double > fLogNormSyst;	std::map< std::string, double > fLogNormSyst;
	std::map< std::string, double > fNoSyst;	std::map< std::string, double > fNoSyst;

	std::string GetDirPath( TDirectory* dir );	std::string GetDirPath( TDirectory* dir );


	ClassDef(RooStats::HistFactory::Measurement, 1);	ClassDef(RooStats::HistFactory::Measurement, 3);

	};	};

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

	#endif	#endif

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

	MinNLLTestStat.h	MinNLLTestStat.h

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

	public:	public:
	MinNLLTestStat() {	MinNLLTestStat() {
	// Proof constructor. Do not use.	// Proof constructor. Do not use.
	fProflts = 0;	fProflts = 0;
	}	}
	MinNLLTestStat(RooAbsPdf& pdf) {	MinNLLTestStat(RooAbsPdf& pdf) {
	fProflts = new ProfileLikelihoodTestStat(pdf);	fProflts = new ProfileLikelihoodTestStat(pdf);
	}	}


	MinNLLTestStat(const MinNLLTestStat& rhs) : fProflts(0) {	MinNLLTestStat(const MinNLLTestStat& rhs) : TestStatistic(rhs), fProfl ts(0) {
	RooAbsPdf * pdf = rhs.fProflts->GetPdf();	RooAbsPdf * pdf = rhs.fProflts->GetPdf();
	if (pdf) fProflts = new ProfileLikelihoodTestStat(*pdf);	if (pdf) fProflts = new ProfileLikelihoodTestStat(*pdf);
	}	}

	MinNLLTestStat & operator=(const MinNLLTestStat& rhs) {	MinNLLTestStat & operator=(const MinNLLTestStat& rhs) {
	if (this == &rhs) return *this;	if (this == &rhs) return *this;
	RooAbsPdf * pdf = rhs.fProflts->GetPdf();	RooAbsPdf * pdf = rhs.fProflts->GetPdf();
	if (fProflts) delete fProflts;	if (fProflts) delete fProflts;
	fProflts = NULL;	fProflts = NULL;
	if (pdf) fProflts = new ProfileLikelihoodTestStat(*pdf);	if (pdf) fProflts = new ProfileLikelihoodTestStat(*pdf);

	skipping to change at line 90	skipping to change at line 90
	delete fProflts;	delete fProflts;
	}	}

	void SetOneSided(Bool_t flag=true) {fProflts->SetOneSided(flag);}	void SetOneSided(Bool_t flag=true) {fProflts->SetOneSided(flag);}
	void SetOneSidedDiscovery(Bool_t flag=true) {fProflts->SetOneSidedDisc overy(flag);}	void SetOneSidedDiscovery(Bool_t flag=true) {fProflts->SetOneSidedDisc overy(flag);}
	void SetReuseNLL(Bool_t flag) { fProflts->SetReuseNLL(flag); }	void SetReuseNLL(Bool_t flag) { fProflts->SetReuseNLL(flag); }
	void SetMinimizer(const char* minimizer){ fProflts->SetMinimizer(minim izer); }	void SetMinimizer(const char* minimizer){ fProflts->SetMinimizer(minim izer); }
	void SetStrategy(Int_t strategy){ fProflts->SetStrategy(strategy); }	void SetStrategy(Int_t strategy){ fProflts->SetStrategy(strategy); }
	void SetTolerance(double tol){ fProflts->SetTolerance(tol); }	void SetTolerance(double tol){ fProflts->SetTolerance(tol); }
	void SetPrintLevel(Int_t printlevel){ fProflts->SetPrintLevel(printlev el); }	void SetPrintLevel(Int_t printlevel){ fProflts->SetPrintLevel(printlev el); }

		void SetLOffset(Bool_t flag=kTRUE) { fProflts->SetLOffset(flag) ; }

	// 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) {

	return fProflts->EvaluateProfileLikelihood(1, data, paramsOfInteres t); //find unconditional NLL minimum	return fProflts->EvaluateProfileLikelihood(1, data, paramsOfInterest ); //find unconditional NLL minimum
	}	}

	virtual void EnableDetailedOutput( bool e=true ) { fProflts->EnableDet ailedOutput(e); }	virtual void EnableDetailedOutput( bool e=true ) { fProflts->EnableDet ailedOutput(e); }

	virtual const RooArgSet* GetDetailedOutput(void) const {	virtual const RooArgSet* GetDetailedOutput(void) const {
	// Returns detailed output. The value returned by this function is updated after each call to Evaluate().	// Returns detailed output. The value returned by this function is updated after each call to Evaluate().
	// The returned RooArgSet contains the following:	// The returned RooArgSet contains the following:
	// <ul>	// <ul>
	// <li> the minimum nll, fitstatus and convergence quality for each fit </li>	// <li> the minimum nll, fitstatus and convergence quality for each fit </li>
	// <li> for all non-constant parameters their value, error and pull </li>	// <li> for all non-constant parameters their value, error and pull </li>

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

	Minimizer.h	Minimizer.h

	// @(#)root/mathcore:$Id: Minimizer.h 39382 2011-05-26 08:31:43Z moneta $	// @(#)root/mathcore:$Id: Minimizer.h 48991 2013-03-28 15:25:11Z rdm $
	// 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

	skipping to change at line 122	skipping to change at line 122

	/// set the function to minimize	/// set the function to minimize
	virtual void SetFunction(const ROOT::Math::IMultiGenFunction & func) = 0 ;	virtual void SetFunction(const ROOT::Math::IMultiGenFunction & func) = 0 ;

	/// set a function to minimize using gradient	/// set a function to minimize using gradient
	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 successfully 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) {
	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() )

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

	ModelConfig.h	ModelConfig.h

	// @(#)root/roostats:$Id: ModelConfig.h 44922 2012-07-05 17:08:03Z moneta $	// @(#)root/roostats:$Id: ModelConfig.h 48844 2013-03-07 11:12:12Z wouter $
	// 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_ModelConfig	#ifndef ROOSTATS_ModelConfig

	skipping to change at line 108	skipping to change at line 108
	}	}

	// Set the Prior Pdf, add to the the workspace if not already there	// Set the Prior Pdf, add to the the workspace if not already there
	virtual void SetPriorPdf(const RooAbsPdf& pdf) {	virtual void SetPriorPdf(const RooAbsPdf& pdf) {
	ImportPdfInWS(pdf);	ImportPdfInWS(pdf);
	SetPriorPdf( pdf.GetName() );	SetPriorPdf( pdf.GetName() );
	}	}

	// specify the parameters of interest in the interval	// specify the parameters of interest in the interval
	virtual void SetParameters(const RooArgSet& set) {	virtual void SetParameters(const RooArgSet& set) {

	fPOIName=std::string(GetName()) + "_POI";	if (!SetHasOnlyParameters(set,"ModelConfig::SetParameters")) return ;
	DefineSetInWS(fPOIName.c_str(), set);	fPOIName=std::string(GetName()) + "_POI";
		DefineSetInWS(fPOIName.c_str(), set);
	}	}


	virtual void SetParametersOfInterest(const RooArgSet& set) {	virtual void SetParametersOfInterest(const RooArgSet& set) {

		if (!SetHasOnlyParameters(set,"ModelConfig::SetParametersOfInterest")) return ;
	SetParameters(set);	SetParameters(set);
	}	}
	// specify the parameters of interest	// specify the parameters of interest
	// through a list of comma-separated arguments already in the workspace	// through a list of comma-separated arguments already in the workspace
	virtual void SetParameters(const char *argList) {	virtual void SetParameters(const char *argList) {
	if(!GetWS()) return;	if(!GetWS()) return;
	SetParameters(GetWS()->argSet(argList));	SetParameters(GetWS()->argSet(argList));
	}	}
	virtual void SetParametersOfInterest(const char *argList) {	virtual void SetParametersOfInterest(const char *argList) {
	SetParameters(argList);	SetParameters(argList);
	}	}

	// specify the nuisance parameters (e.g. the rest of the parameters)	// specify the nuisance parameters (e.g. the rest of the parameters)
	virtual void SetNuisanceParameters(const RooArgSet& set) {	virtual void SetNuisanceParameters(const RooArgSet& set) {

		if (!SetHasOnlyParameters(set,"ModelConfig::SetNuisanceParameters")) r eturn ;
	fNuisParamsName=std::string(GetName()) + "_NuisParams";	fNuisParamsName=std::string(GetName()) + "_NuisParams";
	DefineSetInWS(fNuisParamsName.c_str(), set);	DefineSetInWS(fNuisParamsName.c_str(), set);
	}	}
	// specify the nuisance parameters	// specify the nuisance parameters
	// through a list of comma-separated arguments already in the workspace	// through a list of comma-separated arguments already in the workspace
	virtual void SetNuisanceParameters(const char *argList) {	virtual void SetNuisanceParameters(const char *argList) {
	if(!GetWS()) return;	if(!GetWS()) return;
	SetNuisanceParameters(GetWS()->argSet(argList));	SetNuisanceParameters(GetWS()->argSet(argList));
	}	}

	// specify the constraint parameters	// specify the constraint parameters
	virtual void SetConstraintParameters(const RooArgSet& set) {	virtual void SetConstraintParameters(const RooArgSet& set) {

		if (!SetHasOnlyParameters(set,"ModelConfig::SetConstainedParameters")) return ;
	fConstrParamsName=std::string(GetName()) + "_ConstrainedParams";	fConstrParamsName=std::string(GetName()) + "_ConstrainedParams";
	DefineSetInWS(fConstrParamsName.c_str(), set);	DefineSetInWS(fConstrParamsName.c_str(), set);
	}	}
	// specify the constraint parameters	// specify the constraint parameters
	// through a list of comma-separated arguments already in the workspace	// through a list of comma-separated arguments already in the workspace
	virtual void SetConstraintParameters(const char *argList) {	virtual void SetConstraintParameters(const char *argList) {
	if(!GetWS()) return;	if(!GetWS()) return;
	SetConstraintParameters(GetWS()->argSet(argList));	SetConstraintParameters(GetWS()->argSet(argList));
	}	}

	// specify the observables	// specify the observables
	virtual void SetObservables(const RooArgSet& set) {	virtual void SetObservables(const RooArgSet& set) {

		if (!SetHasOnlyParameters(set,"ModelConfig::SetObservables")) return ;
	fObservablesName=std::string(GetName()) + "_Observables";	fObservablesName=std::string(GetName()) + "_Observables";
	DefineSetInWS(fObservablesName.c_str(), set);	DefineSetInWS(fObservablesName.c_str(), set);
	}	}
	// specify the observables	// specify the observables
	// through a list of comma-separated arguments already in the workspace	// through a list of comma-separated arguments already in the workspace
	virtual void SetObservables(const char *argList) {	virtual void SetObservables(const char *argList) {
	if(!GetWS()) return;	if(!GetWS()) return;
	SetObservables(GetWS()->argSet(argList));	SetObservables(GetWS()->argSet(argList));
	}	}

	// specify the conditional observables	// specify the conditional observables
	virtual void SetConditionalObservables(const RooArgSet& set) {	virtual void SetConditionalObservables(const RooArgSet& set) {

		if (!SetHasOnlyParameters(set,"ModelConfig::SetConditionalObservables" )) return ;
	fConditionalObsName=std::string(GetName()) + "_ConditionalObservables ";	fConditionalObsName=std::string(GetName()) + "_ConditionalObservables ";
	DefineSetInWS(fConditionalObsName.c_str(), set);	DefineSetInWS(fConditionalObsName.c_str(), set);
	}	}
	// specify the conditional observables	// specify the conditional observables
	// through a list of comma-separated arguments already in the workspace	// through a list of comma-separated arguments already in the workspace
	virtual void SetConditionalObservables(const char *argList) {	virtual void SetConditionalObservables(const char *argList) {
	if(!GetWS()) return;	if(!GetWS()) return;
	SetConditionalObservables(GetWS()->argSet(argList));	SetConditionalObservables(GetWS()->argSet(argList));
	}	}

	// specify the global observables	// specify the global observables
	virtual void SetGlobalObservables(const RooArgSet& set) {	virtual void SetGlobalObservables(const RooArgSet& set) {


		if (!SetHasOnlyParameters(set,"ModelConfig::SetGlobalObservables")) re
		turn ;

	// make global observables constant	// make global observables constant
	RooFIter iter = set.fwdIterator();	RooFIter iter = set.fwdIterator();
	RooAbsArg *arg = iter.next();	RooAbsArg *arg = iter.next();
	while(arg != NULL) {	while(arg != NULL) {
	arg->setAttribute("Constant", kTRUE);	arg->setAttribute("Constant", kTRUE);
	arg = iter.next();	arg = iter.next();
	}	}

	fGlobalObsName=std::string(GetName()) + "_GlobalObservables";	fGlobalObsName=std::string(GetName()) + "_GlobalObservables";
	DefineSetInWS(fGlobalObsName.c_str(), set);	DefineSetInWS(fGlobalObsName.c_str(), set);

	skipping to change at line 272	skipping to change at line 281
	/// alias for GetWS()	/// alias for GetWS()
	RooWorkspace * GetWorkspace() const { return 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	// overload the print method
	virtual void Print(Option_t* option = "") const;	virtual void Print(Option_t* option = "") const;

	protected:	protected:


		// helper function to check that content of a given set is exclusively p
		arameters
		Bool_t SetHasOnlyParameters(const RooArgSet& set, const char* errorMsgPr
		efix=0) ;

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

	TRef fRefWS; // WS reference used in the file	TRef fRefWS; // WS reference used in the file

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

	RegressionVariance.h	RegressionVariance.h

	// @(#)root/tmva $Id: RegressionVariance.h 40005 2011-06-27 15:29:10Z stelz er $	// @(#)root/tmva $Id: RegressionVariance.h 48991 2013-03-28 15:25:11Z rdm $
	// 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 : RegressionVariance *	* Class : RegressionVariance *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: Calculate the separation critiera useded in regression *	* Description: Calculate the separation critiera useded in regression *
	* *	* *

	skipping to change at line 83	skipping to change at line 83

	//default constructor	//default constructor
	RegressionVariance(){fName = "Variance for Regression";}	RegressionVariance(){fName = "Variance for Regression";}

	//copy constructor	//copy constructor
	RegressionVariance( const RegressionVariance& s ): fName ( s.fName ) {}	RegressionVariance( const RegressionVariance& s ): fName ( s.fName ) {}

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


	// 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 split in t wo 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 &nLeft, const Double_t &ta rgetLeft, const Double_t &target2Left,	Double_t GetSeparationGain( const Double_t &nLeft, const Double_t &ta rgetLeft, const Double_t &target2Left,
	const Double_t &nTot, const Double_t &tar getTot, const Double_t &target2Tot );	const Double_t &nTot, const Double_t &tar getTot, const Double_t &target2Tot );

	// Return the separation index (a measure for "purity" of the sample" )	// Return the separation index (a measure for "purity" of the sample" )
	virtual Double_t GetSeparationIndex( const Double_t &n, const Double_ t &target, const Double_t &target2 );	virtual Double_t GetSeparationIndex( const Double_t &n, const Double_ t &target, const Double_t &target2 );

	// Return the name of the concrete Index implementation	// Return the name of the concrete Index implementation
	TString GetName() { return fName; }	TString GetName() { return fName; }


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

	RooAbsCategory.h	RooAbsCategory.h

	skipping to change at line 51	skipping to change at line 51

	// Value accessors	// Value accessors
	virtual Int_t getIndex() const ;	virtual Int_t getIndex() const ;
	virtual const char* getLabel() const ;	virtual const char* getLabel() const ;
	Bool_t operator==(Int_t index) const ;	Bool_t operator==(Int_t index) const ;
	Bool_t operator!=(Int_t index) { return !operator==(index);}	Bool_t operator!=(Int_t index) { return !operator==(index);}
	Bool_t operator==(const char* label) const ;	Bool_t operator==(const char* label) const ;
	Bool_t operator!=(const char* label) { return !operator==(label);}	Bool_t operator!=(const char* label) { return !operator==(label);}
	virtual Bool_t operator==(const RooAbsArg& other) ;	virtual Bool_t operator==(const RooAbsArg& other) ;
	Bool_t operator!=(const RooAbsArg& other) { return !operator==(ot her);}	Bool_t operator!=(const RooAbsArg& other) { return !operator==(ot her);}

		virtual Bool_t isIdentical(const RooAbsArg& other, Bool_t assumeSameType= kFALSE) ;

	Bool_t isValidIndex(Int_t index) const ;	Bool_t isValidIndex(Int_t index) const ;
	Bool_t isValidLabel(const char* label) const ;	Bool_t isValidLabel(const char* label) const ;
	const RooCatType* lookupType(Int_t index, Bool_t printError=kFALSE) const ;	const RooCatType* lookupType(Int_t index, Bool_t printError=kFALSE) const ;
	const RooCatType* lookupType(const char* label, Bool_t printError=kFALSE) const ;	const RooCatType* lookupType(const char* label, Bool_t printError=kFALSE) const ;
	const RooCatType* lookupType(const RooCatType& type, Bool_t printError=kF ALSE) const ;	const RooCatType* lookupType(const RooCatType& type, Bool_t printError=kF ALSE) const ;
	TIterator* typeIterator() const ;	TIterator* typeIterator() const ;
	Int_t numTypes(const char* /rangeName/=0) const {	Int_t numTypes(const char* /rangeName/=0) const {
	// Return number of types defined (in range named rangeName if rangeNam e!=0)	// Return number of types defined (in range named rangeName if rangeNam e!=0)
	return _types.GetEntries() ;	return _types.GetEntries() ;

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

	RooChi2Var.h	RooChi2Var.h

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

	RooChi2Var(const char name, const char title, RooAbsPdf& pdf, RooDataHi st& data,	RooChi2Var(const char name, const char title, RooAbsPdf& pdf, RooDataHi st& data,
	const RooCmdArg& arg1 , const RooCmdArg& arg2=Ro oCmdArg::none(),const RooCmdArg& arg3=RooCmdArg::none(),	const RooCmdArg& arg1 , const RooCmdArg& arg2=Ro oCmdArg::none(),const RooCmdArg& arg3=RooCmdArg::none(),
	const RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5= RooCmdArg::none(),const RooCmdArg& arg6=RooCmdArg::none(),	const RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5= RooCmdArg::none(),const RooCmdArg& arg6=RooCmdArg::none(),
	const RooCmdArg& arg7=RooCmdArg::none(), const RooCmdArg& arg8= RooCmdArg::none(),const RooCmdArg& arg9=RooCmdArg::none()) ;	const RooCmdArg& arg7=RooCmdArg::none(), const RooCmdArg& arg8= RooCmdArg::none(),const RooCmdArg& arg9=RooCmdArg::none()) ;

	enum FuncMode { Function, Pdf, ExtendedPdf } ;	enum FuncMode { Function, Pdf, ExtendedPdf } ;

	RooChi2Var(const char name, const char title, RooAbsPdf& pdf, RooDataHi st& data,	RooChi2Var(const char name, const char title, RooAbsPdf& pdf, RooDataHi st& data,
	Bool_t extended=kFALSE, const char* rangeName=0, const char* add CoefRangeName=0,	Bool_t extended=kFALSE, const char* rangeName=0, const char* add CoefRangeName=0,

	Int_t nCPU=1, Bool_t interleave=kFALSE, Bool_t verbose=kTRUE, B ool_t splitCutRange=kTRUE, RooDataHist::ErrorType=RooDataHist::SumW2) ;	Int_t nCPU=1, RooFit::MPSplit interleave=RooFit::BulkPartition, Bool_t verbose=kTRUE, Bool_t splitCutRange=kTRUE, RooDataHist::ErrorType=R ooDataHist::SumW2) ;

	RooChi2Var(const char name, const char title, RooAbsReal& func, RooData Hist& data,	RooChi2Var(const char name, const char title, RooAbsReal& func, RooData Hist& data,
	const RooArgSet& projDeps, FuncMode funcMode, const char* range Name=0, const char* addCoefRangeName=0,	const RooArgSet& projDeps, FuncMode funcMode, const char* range Name=0, const char* addCoefRangeName=0,

	Int_t nCPU=1, Bool_t interleave=kFALSE, Bool_t verbose=kTRUE, B ool_t splitCutRange=kTRUE, RooDataHist::ErrorType=RooDataHist::SumW2) ;	Int_t nCPU=1, RooFit::MPSplit interleave=RooFit::BulkPartition, Bool_t verbose=kTRUE, Bool_t splitCutRange=kTRUE, RooDataHist::ErrorType=R ooDataHist::SumW2) ;

	RooChi2Var(const RooChi2Var& other, const char* name=0);	RooChi2Var(const RooChi2Var& other, const char* name=0);
	virtual TObject* clone(const char* newname) const { return new RooChi2Var (*this,newname); }	virtual TObject* clone(const char* newname) const { return new RooChi2Var (*this,newname); }

	virtual RooAbsTestStatistic* create(const char name, const char title, RooAbsReal& pdf, RooAbsData& dhist,	virtual RooAbsTestStatistic* create(const char name, const char title, RooAbsReal& pdf, RooAbsData& dhist,
	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 verbose=kTRUE, Bool_t splitCutRange=kTRUE) {	Int_t nCPU=1, RooFit::MPSplit interlea ve=RooFit::BulkPartition,Bool_t verbose=kTRUE, Bool_t splitCutRange=kTRUE) {
	// Virtual constructor	// Virtual constructor
	return new RooChi2Var(name,title,(RooAbsPdf&)pdf,(RooDataHist&)dhist,pr ojDeps,_funcMode,rangeName,	return new RooChi2Var(name,title,(RooAbsPdf&)pdf,(RooDataHist&)dhist,pr ojDeps,_funcMode,rangeName,
	addCoefRangeName,nCPU,interleave,verbose, splitCut Range,_etype) ;	addCoefRangeName,nCPU,interleave,verbose, splitCut Range,_etype) ;
	}	}

	virtual ~RooChi2Var();	virtual ~RooChi2Var();

	virtual Double_t defaultErrorLevel() const {	virtual Double_t defaultErrorLevel() const {
	// The default error level for MINUIT error analysis for a chi^2 is 1.0	// The default error level for MINUIT error analysis for a chi^2 is 1.0
	return 1.0 ;	return 1.0 ;

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

	RooClassFactory.h	RooClassFactory.h

	skipping to change at line 48	skipping to change at line 48

	static RooAbsPdf* makePdfInstance(const char* className, const char* name , const char* expression, const RooArgList& vars, const char* intExpression =0) ;	static RooAbsPdf* makePdfInstance(const char* className, const char* name , const char* expression, const RooArgList& vars, const char* intExpression =0) ;
	static RooAbsPdf* makePdfInstance(const char* name, const char* expressio n, const RooArgList& vars, const char* intExpression=0) ;	static RooAbsPdf* makePdfInstance(const char* name, const char* expressio n, const RooArgList& vars, const char* intExpression=0) ;

	static Bool_t makeAndCompilePdf(const char* name, const char* expression, const RooArgList& vars, const char* intExpression=0) ;	static Bool_t makeAndCompilePdf(const char* name, const char* expression, const RooArgList& vars, const char* intExpression=0) ;
	static Bool_t makeAndCompileFunction(const char* name, const char* expres sion, const RooArgList& args, const char* intExpression=0) ;	static Bool_t makeAndCompileFunction(const char* name, const char* expres sion, const RooArgList& args, const char* intExpression=0) ;

	static Bool_t makePdf(const char* name, const char* realArgNames=0, const char* catArgNames=0,	static Bool_t makePdf(const char* name, const char* realArgNames=0, const char* catArgNames=0,
	const char* expression="1.0", Bool_t hasAnaInt=kFALS E, Bool_t hasIntGen=kFALSE, const char* intExpression=0) ;	const char* expression="1.0", Bool_t hasAnaInt=kFALS E, Bool_t hasIntGen=kFALSE, const char* intExpression=0) ;
	static Bool_t makeFunction(const char* name, const char* realArgNames=0, const char* catArgNames=0,	static Bool_t makeFunction(const char* name, const char* realArgNames=0, const char* catArgNames=0,

	const char* expresion="1.0", Bool_t hasAnaInt=k FALSE, const char* intExpression=0) ;	const char* expression="1.0", Bool_t hasAnaInt= kFALSE, const char* intExpression=0) ;
	static Bool_t makeClass(const char* className, const char* name, const ch ar* realArgNames=0, const char* catArgNames=0,	static Bool_t makeClass(const char* className, const char* name, const ch ar* realArgNames=0, const char* catArgNames=0,
	const char* expression="1.0", Bool_t hasAnaInt=kFA LSE, Bool_t hasIntGen=kFALSE, const char* intExpression=0) ;	const char* expression="1.0", Bool_t hasAnaInt=kFA LSE, Bool_t hasIntGen=kFALSE, const char* intExpression=0) ;

	class ClassFacIFace : public RooFactoryWSTool::IFace {	class ClassFacIFace : public RooFactoryWSTool::IFace {
	public:	public:
	std::string create(RooFactoryWSTool& ft, const char* typeName, const ch ar* instanceName, std::vector<std::string> args) ;	std::string create(RooFactoryWSTool& ft, const char* typeName, const ch ar* instanceName, std::vector<std::string> args) ;
	} ;	} ;

	protected:	protected:


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

	RooRealVar.h	RooRealVar.h

	skipping to change at line 98	skipping to change at line 98
	// I/O streaming interface (machine readable)	// I/O streaming interface (machine readable)
	virtual Bool_t readFromStream(std::istream& is, Bool_t compact, Bool_t ve rbose=kFALSE) ;	virtual Bool_t readFromStream(std::istream& is, Bool_t compact, Bool_t ve rbose=kFALSE) ;
	virtual void writeToStream(std::ostream& os, Bool_t compact) const ;	virtual void writeToStream(std::ostream& os, Bool_t compact) const ;

	// We implement a fundamental type of AbsArg that can be stored in a data set	// We implement a fundamental type of AbsArg that can be stored in a data set
	inline virtual Bool_t isFundamental() const { return kTRUE; }	inline virtual Bool_t isFundamental() const { return kTRUE; }

	// Force to be a leaf-node of any expression tree, even if we have (shape ) servers	// Force to be a leaf-node of any expression tree, even if we have (shape ) servers
	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()>0 \|\| _proxyList.GetSize()>0)?kTRUE:kFALSE ;	return (_serverList.GetSize()>0 \|\| _proxyList.GetEntries()>0)?kTRUE:kFA LSE;
	}	}

	// Printing interface (human readable)	// Printing interface (human readable)
	virtual void printValue(std::ostream& os) const ;	virtual void printValue(std::ostream& os) const ;
	virtual void printExtras(std::ostream& os) const ;	virtual void printExtras(std::ostream& os) const ;
	virtual void printMultiline(std::ostream& os, Int_t contents, Bool_t verb ose=kFALSE, TString indent="") const ;	virtual void printMultiline(std::ostream& os, Int_t contents, Bool_t verb ose=kFALSE, TString indent="") const ;
	virtual Int_t defaultPrintContents(Option_t* opt) const ;	virtual Int_t defaultPrintContents(Option_t* opt) const ;

	TString* format(const RooCmdArg& formatArg) const ;	TString* format(const RooCmdArg& formatArg) const ;
	TString* format(Int_t sigDigits, const char *options) const ;	TString* format(Int_t sigDigits, const char *options) const ;

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

	RootFinder.h	RootFinder.h

	// @(#)root/mathmore:$Id: RootFinder.h 33942 2010-06-16 13:12:17Z moneta $	// @(#)root/mathmore:$Id: RootFinder.h 48991 2013-03-28 15:25:11Z rdm $
	// 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 46	skipping to change at line 46
	#endif	#endif

	#ifndef ROOT_Math_IRootFinderMethod	#ifndef ROOT_Math_IRootFinderMethod
	#include "Math/IRootFinderMethod.h"	#include "Math/IRootFinderMethod.h"
	#endif	#endif

	/**	/**
	@defgroup RootFinders One-dimensional Root-Finding algorithms	@defgroup RootFinders One-dimensional Root-Finding algorithms
	Various implementation esists in MathCore and MathMore	Various implementation esists in MathCore and MathMore
	The user interacts with a proxy class ROOT::Math::RootFinder which creat es behing	The user interacts with a proxy class ROOT::Math::RootFinder which creat es behing

	the choosen algorithms which are implemented using the ROOT::Math::IRoot FinderMethod interface	the chosen algorithms which are implemented using the ROOT::Math::IRootF inderMethod interface

	@ingroup NumAlgo	@ingroup NumAlgo
	*/	*/

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

	//_________________________________________________________________________ ____________	//_________________________________________________________________________ ____________
	/**	/**
	User Class to find the Root of one dimensional functions.	User Class to find the Root of one dimensional functions.

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 40005 2011-06-27 15:29:10Z stelzer $	// @(#)root/tmva $Id: SeparationBase.h 48991 2013-03-28 15:25:11Z rdm $
	// 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 101	skipping to change at line 101

	// 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 split in t wo 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 );

	// Return the separation index (a measure for "purity" of the sample" )	// Return the separation index (a measure for "purity" of the sample" )
	virtual Double_t GetSeparationIndex( const Double_t &s, const Double_ t &b ) = 0;	virtual Double_t GetSeparationIndex( const Double_t &s, const Double_ t &b ) = 0;

	// Return the name of the concrete Index implementation	// Return the name of the concrete Index implementation
	const TString& GetName() { return fName; }	const TString& GetName() { return fName; }


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

	TBranch.h	TBranch.h

	// @(#)root/tree:$Id: TBranch.h 40872 2011-09-13 21:33:33Z pcanal $	// @(#)root/tree:$Id: TBranch.h 48991 2013-03-28 15:25:11Z rdm $
	// 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 89	skipping to change at line 89
	Long64_t fFirstBasketEntry;//! First entry in the current basket.	Long64_t fFirstBasketEntry;//! First entry in the current basket.
	Long64_t fNextBasketEntry; //! Next entry that will requires us to go to the next basket	Long64_t fNextBasketEntry; //! Next entry that will requires us to go to the next basket
	TBasket *fCurrentBasket; //! Pointer to the current basket.	TBasket *fCurrentBasket; //! Pointer to the current basket.
	Long64_t fEntries; // Number of entries	Long64_t fEntries; // Number of entries
	Long64_t fFirstEntry; // Number of the first entry in this bran ch	Long64_t fFirstEntry; // Number of the first entry in this bran ch
	Long64_t fTotBytes; // Total number of bytes in all leaves be fore compression	Long64_t fTotBytes; // Total number of bytes in all leaves be fore compression
	Long64_t fZipBytes; // Total number of bytes in all leaves af ter compression	Long64_t fZipBytes; // Total number of bytes in all leaves af ter compression
	TObjArray fBranches; //-> List of Branches of this branch	TObjArray fBranches; //-> List of Branches of this branch
	TObjArray fLeaves; //-> List of leaves of this branch	TObjArray fLeaves; //-> List of leaves of this branch
	TObjArray fBaskets; //-> List of baskets of this branch	TObjArray fBaskets; //-> List of baskets of this branch

	Int_t *fBasketBytes; //[fMaxBaskets] Lenght of baskets on file	Int_t *fBasketBytes; //[fMaxBaskets] Length of baskets on file
	Long64_t *fBasketEntry; //[fMaxBaskets] Table of first entry in ea ck basket	Long64_t *fBasketEntry; //[fMaxBaskets] Table of first entry in ea ck basket
	Long64_t *fBasketSeek; //[fMaxBaskets] Addresses of baskets on fi le	Long64_t *fBasketSeek; //[fMaxBaskets] Addresses of baskets on fi le
	TTree *fTree; //! Pointer to Tree header	TTree *fTree; //! Pointer to Tree header
	TBranch *fMother; //! Pointer to top-level parent branch in the tree.	TBranch *fMother; //! Pointer to top-level parent branch in the tree.
	TBranch *fParent; //! Pointer to parent branch.	TBranch *fParent; //! Pointer to parent branch.
	char *fAddress; //! Address of 1st leaf (variable or objec t)	char *fAddress; //! Address of 1st leaf (variable or objec t)
	TDirectory *fDirectory; //! Pointer to directory where this branch buffers are stored	TDirectory *fDirectory; //! Pointer to directory where this branch buffers are stored
	TString fFileName; // Name of file where buffers are stored ("" if in same file as Tree header)	TString fFileName; // Name of file where buffers are stored ("" if in same file as Tree header)
	TBuffer *fEntryBuffer; //! Buffer used to directly pass the conte nt without streaming	TBuffer *fEntryBuffer; //! Buffer used to directly pass the conte nt without streaming
	TList *fBrowsables; //! List of TVirtualBranchBrowsables used for Browse()	TList *fBrowsables; //! List of TVirtualBranchBrowsables used for Browse()

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

	TBuffer.h	TBuffer.h

	// @(#)root/base:$Id: TBuffer.h 40872 2011-09-13 21:33:33Z pcanal $	// @(#)root/base:$Id: TBuffer.h 48931 2013-03-25 16:43:38Z pcanal $
	// Author: Rene Brun, Philippe Canal, Fons Rademakers 04/05/96	// Author: Rene Brun, Philippe Canal, Fons Rademakers 04/05/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 216	skipping to change at line 216
	virtual void ReadFastArray(Int_t *i, Int_t n) = 0;	virtual void ReadFastArray(Int_t *i, Int_t n) = 0;
	virtual void ReadFastArray(UInt_t *i, Int_t n) = 0;	virtual void ReadFastArray(UInt_t *i, Int_t n) = 0;
	virtual void ReadFastArray(Long_t *l, Int_t n) = 0;	virtual void ReadFastArray(Long_t *l, Int_t n) = 0;
	virtual void ReadFastArray(ULong_t *l, Int_t n) = 0;	virtual void ReadFastArray(ULong_t *l, Int_t n) = 0;
	virtual void ReadFastArray(Long64_t *l, Int_t n) = 0;	virtual void ReadFastArray(Long64_t *l, Int_t n) = 0;
	virtual void ReadFastArray(ULong64_t *l, Int_t n) = 0;	virtual void ReadFastArray(ULong64_t *l, Int_t n) = 0;
	virtual void ReadFastArray(Float_t *f, Int_t n) = 0;	virtual void ReadFastArray(Float_t *f, Int_t n) = 0;
	virtual void ReadFastArray(Double_t *d, Int_t n) = 0;	virtual void ReadFastArray(Double_t *d, Int_t n) = 0;
	virtual void ReadFastArrayFloat16(Float_t f, Int_t n, TStreamerE lement ele=0) = 0;	virtual void ReadFastArrayFloat16(Float_t f, Int_t n, TStreamerE lement ele=0) = 0;
	virtual void ReadFastArrayDouble32(Double_t d, Int_t n, TStreame rElement ele=0) = 0;	virtual void ReadFastArrayDouble32(Double_t d, Int_t n, TStreame rElement ele=0) = 0;

		virtual void ReadFastArrayWithFactor(Float_t *ptr, Int_t n, Double
		_t factor, Double_t minvalue) = 0;
		virtual void ReadFastArrayWithNbits(Float_t *ptr, Int_t n, Int_t n
		bits) = 0;
		virtual void ReadFastArrayWithFactor(Double_t *ptr, Int_t n, Doubl
		e_t factor, Double_t minvalue) = 0;
		virtual void ReadFastArrayWithNbits(Double_t *ptr, Int_t n, Int_t
		nbits) = 0;
	virtual void ReadFastArray(void start , const TClass cl, Int_t n=1, TMemberStreamer s=0, const TClass onFileClass=0) = 0;	virtual void ReadFastArray(void start , const TClass cl, Int_t n=1, TMemberStreamer s=0, const TClass onFileClass=0) = 0;
	virtual void ReadFastArray(void *startp, const TClass cl, Int_t n=1, Bool_t isPreAlloc=kFALSE, TMemberStreamer s=0, const TClass onFileCl ass=0) = 0;	virtual void ReadFastArray(void *startp, const TClass cl, Int_t n=1, Bool_t isPreAlloc=kFALSE, TMemberStreamer s=0, const TClass onFileCl ass=0) = 0;

	virtual void WriteArray(const Bool_t *b, Int_t n) = 0;	virtual void WriteArray(const Bool_t *b, Int_t n) = 0;
	virtual void WriteArray(const Char_t *c, Int_t n) = 0;	virtual void WriteArray(const Char_t *c, Int_t n) = 0;
	virtual void WriteArray(const UChar_t *c, Int_t n) = 0;	virtual void WriteArray(const UChar_t *c, Int_t n) = 0;
	virtual void WriteArray(const Short_t *h, Int_t n) = 0;	virtual void WriteArray(const Short_t *h, Int_t n) = 0;
	virtual void WriteArray(const UShort_t *h, Int_t n) = 0;	virtual void WriteArray(const UShort_t *h, Int_t n) = 0;
	virtual void WriteArray(const Int_t *i, Int_t n) = 0;	virtual void WriteArray(const Int_t *i, Int_t n) = 0;
	virtual void WriteArray(const UInt_t *i, Int_t n) = 0;	virtual void WriteArray(const UInt_t *i, Int_t n) = 0;

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

	TBufferFile.h	TBufferFile.h

	// @(#)root/io:$Id: TBufferFile.h 40872 2011-09-13 21:33:33Z pcanal $	// @(#)root/io:$Id: TBufferFile.h 48931 2013-03-25 16:43:38Z pcanal $
	// Author: Rene Brun 17/01/2007	// Author: Rene Brun 17/01/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 211	skipping to change at line 211
	virtual void ReadFastArray(Int_t *i, Int_t n);	virtual void ReadFastArray(Int_t *i, Int_t n);
	virtual void ReadFastArray(UInt_t *i, Int_t n);	virtual void ReadFastArray(UInt_t *i, Int_t n);
	virtual void ReadFastArray(Long_t *l, Int_t n);	virtual void ReadFastArray(Long_t *l, Int_t n);
	virtual void ReadFastArray(ULong_t *l, Int_t n);	virtual void ReadFastArray(ULong_t *l, Int_t n);
	virtual void ReadFastArray(Long64_t *l, Int_t n);	virtual void ReadFastArray(Long64_t *l, Int_t n);
	virtual void ReadFastArray(ULong64_t *l, Int_t n);	virtual void ReadFastArray(ULong64_t *l, Int_t n);
	virtual void ReadFastArray(Float_t *f, Int_t n);	virtual void ReadFastArray(Float_t *f, Int_t n);
	virtual void ReadFastArray(Double_t *d, Int_t n);	virtual void ReadFastArray(Double_t *d, Int_t n);
	virtual void ReadFastArrayFloat16(Float_t f, Int_t n, TStreamerE lement ele=0);	virtual void ReadFastArrayFloat16(Float_t f, Int_t n, TStreamerE lement ele=0);
	virtual void ReadFastArrayDouble32(Double_t d, Int_t n, TStreame rElement ele=0);	virtual void ReadFastArrayDouble32(Double_t d, Int_t n, TStreame rElement ele=0);

		virtual void ReadFastArrayWithFactor(Float_t *ptr, Int_t n, Double
		_t factor, Double_t minvalue) ;
		virtual void ReadFastArrayWithNbits(Float_t *ptr, Int_t n, Int_t n
		bits);
		virtual void ReadFastArrayWithFactor(Double_t *ptr, Int_t n, Doubl
		e_t factor, Double_t minvalue);
		virtual void ReadFastArrayWithNbits(Double_t *ptr, Int_t n, Int_t
		nbits) ;
	virtual void ReadFastArray(void start , const TClass cl, Int_t n=1, TMemberStreamer s=0, const TClass onFileClass=0 );	virtual void ReadFastArray(void start , const TClass cl, Int_t n=1, TMemberStreamer s=0, const TClass onFileClass=0 );
	virtual void ReadFastArray(void *startp, const TClass cl, Int_t n=1, Bool_t isPreAlloc=kFALSE, TMemberStreamer s=0, const TClass onFileCl ass=0);	virtual void ReadFastArray(void *startp, const TClass cl, Int_t n=1, Bool_t isPreAlloc=kFALSE, TMemberStreamer s=0, const TClass onFileCl ass=0);

	virtual void WriteArray(const Bool_t *b, Int_t n);	virtual void WriteArray(const Bool_t *b, Int_t n);
	virtual void WriteArray(const Char_t *c, Int_t n);	virtual void WriteArray(const Char_t *c, Int_t n);
	virtual void WriteArray(const UChar_t *c, Int_t n);	virtual void WriteArray(const UChar_t *c, Int_t n);
	virtual void WriteArray(const Short_t *h, Int_t n);	virtual void WriteArray(const Short_t *h, Int_t n);
	virtual void WriteArray(const UShort_t *h, Int_t n);	virtual void WriteArray(const UShort_t *h, Int_t n);
	virtual void WriteArray(const Int_t *i, Int_t n);	virtual void WriteArray(const Int_t *i, Int_t n);
	virtual void WriteArray(const UInt_t *i, Int_t n);	virtual void WriteArray(const UInt_t *i, Int_t n);

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

	TBufferSQL.h	TBufferSQL.h

	// @(#)root/tree:$Id: TBufferSQL.h 25450 2008-09-18 21:13:42Z pcanal $	// @(#)root/tree:$Id: TBufferSQL.h 48931 2013-03-25 16:43:38Z pcanal $
	// Author: Philippe Canal 2005	// Author: Philippe Canal 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 120	skipping to change at line 120
	virtual void ReadFastArray(Int_t *, Int_t );	virtual void ReadFastArray(Int_t *, Int_t );
	virtual void ReadFastArray(UInt_t *, Int_t );	virtual void ReadFastArray(UInt_t *, Int_t );
	virtual void ReadFastArray(Long_t *, Int_t );	virtual void ReadFastArray(Long_t *, Int_t );
	virtual void ReadFastArray(ULong_t *, Int_t );	virtual void ReadFastArray(ULong_t *, Int_t );
	virtual void ReadFastArray(Long64_t *, Int_t );	virtual void ReadFastArray(Long64_t *, Int_t );
	virtual void ReadFastArray(ULong64_t *, Int_t );	virtual void ReadFastArray(ULong64_t *, Int_t );
	virtual void ReadFastArray(Float_t *, Int_t );	virtual void ReadFastArray(Float_t *, Int_t );
	virtual void ReadFastArray(Double_t *, Int_t );	virtual void ReadFastArray(Double_t *, Int_t );
	virtual void ReadFastArrayFloat16(Float_t f, Int_t n, TStreamerE lement ele=0);	virtual void ReadFastArrayFloat16(Float_t f, Int_t n, TStreamerE lement ele=0);
	virtual void ReadFastArrayDouble32(Double_t d, Int_t n, TStreame rElement ele=0);	virtual void ReadFastArrayDouble32(Double_t d, Int_t n, TStreame rElement ele=0);

		virtual void ReadFastArrayWithFactor(Float_t *ptr, Int_t n, Double
		_t factor, Double_t minvalue) ;
		virtual void ReadFastArrayWithNbits(Float_t *ptr, Int_t n, Int_t n
		bits);
		virtual void ReadFastArrayWithFactor(Double_t *ptr, Int_t n, Doubl
		e_t factor, Double_t minvalue);
		virtual void ReadFastArrayWithNbits(Double_t *ptr, Int_t n, Int_t
		nbits) ;
	virtual void ReadFastArray(void , const TClass , Int_t n=1, TMe mberStreamer s=0, const TClass onFileClass=0);	virtual void ReadFastArray(void , const TClass , Int_t n=1, TMe mberStreamer s=0, const TClass onFileClass=0);
	virtual void ReadFastArray(void *, const TClass , Int_t n=1, Boo l_t isPreAlloc=kFALSE, TMemberStreamer s=0, const TClass onFileClass=0);	virtual void ReadFastArray(void *, const TClass , Int_t n=1, Boo l_t isPreAlloc=kFALSE, TMemberStreamer s=0, const TClass onFileClass=0);

	ClassDef(TBufferSQL, 1); // Implementation of TBuffer to load and write to a SQL database	ClassDef(TBufferSQL, 1); // Implementation of TBuffer to load and write to a SQL database

	};	};

	#endif	#endif

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

	TBufferSQL2.h	TBufferSQL2.h

	// @(#)root/sql:$Id: TBufferSQL2.h 40872 2011-09-13 21:33:33Z pcanal $	// @(#)root/sql:$Id: TBufferSQL2.h 48931 2013-03-25 16:43:38Z pcanal $
	// Author: Sergey Linev 20/11/2005	// Author: Sergey Linev 20/11/2005

	#ifndef ROOT_TBufferSQL2	#ifndef ROOT_TBufferSQL2
	#define ROOT_TBufferSQL2	#define ROOT_TBufferSQL2

	/////////////////////////////////////////////////////////////////////////	/////////////////////////////////////////////////////////////////////////
	// //	// //
	// TBufferSQL2 class used in TSQLFile to convert binary object data //	// TBufferSQL2 class used in TSQLFile to convert binary object data //
	// to SQL statements, supplied to DB server //	// to SQL statements, supplied to DB server //
	// //	// //

	skipping to change at line 225	skipping to change at line 225
	virtual void ReadFastArray(Int_t *i, Int_t n);	virtual void ReadFastArray(Int_t *i, Int_t n);
	virtual void ReadFastArray(UInt_t *i, Int_t n);	virtual void ReadFastArray(UInt_t *i, Int_t n);
	virtual void ReadFastArray(Long_t *l, Int_t n);	virtual void ReadFastArray(Long_t *l, Int_t n);
	virtual void ReadFastArray(ULong_t *l, Int_t n);	virtual void ReadFastArray(ULong_t *l, Int_t n);
	virtual void ReadFastArray(Long64_t *l, Int_t n);	virtual void ReadFastArray(Long64_t *l, Int_t n);
	virtual void ReadFastArray(ULong64_t *l, Int_t n);	virtual void ReadFastArray(ULong64_t *l, Int_t n);
	virtual void ReadFastArray(Float_t *f, Int_t n);	virtual void ReadFastArray(Float_t *f, Int_t n);
	virtual void ReadFastArray(Double_t *d, Int_t n);	virtual void ReadFastArray(Double_t *d, Int_t n);
	virtual void ReadFastArrayFloat16(Float_t f, Int_t n, TStreamerEle ment ele=0);	virtual void ReadFastArrayFloat16(Float_t f, Int_t n, TStreamerEle ment ele=0);
	virtual void ReadFastArrayDouble32(Double_t d, Int_t n, TStreamerE lement ele=0);	virtual void ReadFastArrayDouble32(Double_t d, Int_t n, TStreamerE lement ele=0);

		virtual void ReadFastArrayWithFactor(Float_t *ptr, Int_t n, Double_t
		factor, Double_t minvalue) ;
		virtual void ReadFastArrayWithNbits(Float_t *ptr, Int_t n, Int_t nbi
		ts);
		virtual void ReadFastArrayWithFactor(Double_t *ptr, Int_t n, Double_
		t factor, Double_t minvalue);
		virtual void ReadFastArrayWithNbits(Double_t *ptr, Int_t n, Int_t nb
		its) ;

	virtual void WriteArray(const Bool_t *b, Int_t n);	virtual void WriteArray(const Bool_t *b, Int_t n);
	virtual void WriteArray(const Char_t *c, Int_t n);	virtual void WriteArray(const Char_t *c, Int_t n);
	virtual void WriteArray(const UChar_t *c, Int_t n);	virtual void WriteArray(const UChar_t *c, Int_t n);
	virtual void WriteArray(const Short_t *h, Int_t n);	virtual void WriteArray(const Short_t *h, Int_t n);
	virtual void WriteArray(const UShort_t *h, Int_t n);	virtual void WriteArray(const UShort_t *h, Int_t n);
	virtual void WriteArray(const Int_t *i, Int_t n);	virtual void WriteArray(const Int_t *i, Int_t n);
	virtual void WriteArray(const UInt_t *i, Int_t n);	virtual void WriteArray(const UInt_t *i, Int_t n);
	virtual void WriteArray(const Long_t *l, Int_t n);	virtual void WriteArray(const Long_t *l, Int_t n);
	virtual void WriteArray(const ULong_t *l, Int_t n);	virtual void WriteArray(const ULong_t *l, Int_t n);

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

	TBufferXML.h	TBufferXML.h

	// @(#)root/xml:$Id: TBufferXML.h 40872 2011-09-13 21:33:33Z pcanal $	// @(#)root/xml:$Id: TBufferXML.h 48931 2013-03-25 16:43:38Z 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 140	skipping to change at line 140
	virtual void ReadFastArray(Int_t *i, Int_t n);	virtual void ReadFastArray(Int_t *i, Int_t n);
	virtual void ReadFastArray(UInt_t *i, Int_t n);	virtual void ReadFastArray(UInt_t *i, Int_t n);
	virtual void ReadFastArray(Long_t *l, Int_t n);	virtual void ReadFastArray(Long_t *l, Int_t n);
	virtual void ReadFastArray(ULong_t *l, Int_t n);	virtual void ReadFastArray(ULong_t *l, Int_t n);
	virtual void ReadFastArray(Long64_t *l, Int_t n);	virtual void ReadFastArray(Long64_t *l, Int_t n);
	virtual void ReadFastArray(ULong64_t *l, Int_t n);	virtual void ReadFastArray(ULong64_t *l, Int_t n);
	virtual void ReadFastArray(Float_t *f, Int_t n);	virtual void ReadFastArray(Float_t *f, Int_t n);
	virtual void ReadFastArray(Double_t *d, Int_t n);	virtual void ReadFastArray(Double_t *d, Int_t n);
	virtual void ReadFastArrayFloat16(Float_t f, Int_t n, TStreamerEle ment ele=0);	virtual void ReadFastArrayFloat16(Float_t f, Int_t n, TStreamerEle ment ele=0);
	virtual void ReadFastArrayDouble32(Double_t d, Int_t n, TStreamerE lement ele=0);	virtual void ReadFastArrayDouble32(Double_t d, Int_t n, TStreamerE lement ele=0);

		virtual void ReadFastArrayWithFactor(Float_t *ptr, Int_t n, Double_t
		factor, Double_t minvalue) ;
		virtual void ReadFastArrayWithNbits(Float_t *ptr, Int_t n, Int_t nbi
		ts);
		virtual void ReadFastArrayWithFactor(Double_t *ptr, Int_t n, Double_
		t factor, Double_t minvalue);
		virtual void ReadFastArrayWithNbits(Double_t *ptr, Int_t n, Int_t nb
		its) ;

	virtual void WriteArray(const Bool_t *b, Int_t n);	virtual void WriteArray(const Bool_t *b, Int_t n);
	virtual void WriteArray(const Char_t *c, Int_t n);	virtual void WriteArray(const Char_t *c, Int_t n);
	virtual void WriteArray(const UChar_t *c, Int_t n);	virtual void WriteArray(const UChar_t *c, Int_t n);
	virtual void WriteArray(const Short_t *h, Int_t n);	virtual void WriteArray(const Short_t *h, Int_t n);
	virtual void WriteArray(const UShort_t *h, Int_t n);	virtual void WriteArray(const UShort_t *h, Int_t n);
	virtual void WriteArray(const Int_t *i, Int_t n);	virtual void WriteArray(const Int_t *i, Int_t n);
	virtual void WriteArray(const UInt_t *i, Int_t n);	virtual void WriteArray(const UInt_t *i, Int_t n);
	virtual void WriteArray(const Long_t *l, Int_t n);	virtual void WriteArray(const Long_t *l, Int_t n);
	virtual void WriteArray(const ULong_t *l, Int_t n);	virtual void WriteArray(const ULong_t *l, Int_t n);

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

	TCint.h	TCint.h

	// @(#)root/meta:$Id: TCint.h 43515 2012-03-27 21:15:53Z pcanal $	// @(#)root/meta:$Id: TCint.h 48771 2013-02-28 19:49:49Z pcanal $
	// Author: Fons Rademakers 01/03/96	// Author: Fons Rademakers 01/03/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 281	skipping to change at line 281
	virtual Bool_t MethodInfo_IsValid(MethodInfo_t *minfo) const;	virtual Bool_t MethodInfo_IsValid(MethodInfo_t *minfo) const;
	virtual int MethodInfo_NArg(MethodInfo_t *minfo) const;	virtual int MethodInfo_NArg(MethodInfo_t *minfo) const;
	virtual int MethodInfo_NDefaultArg(MethodInfo_t *minfo) const;	virtual int MethodInfo_NDefaultArg(MethodInfo_t *minfo) const;
	virtual int MethodInfo_Next(MethodInfo_t *minfo) const;	virtual int MethodInfo_Next(MethodInfo_t *minfo) const;
	virtual Long_t MethodInfo_Property(MethodInfo_t *minfo) const;	virtual Long_t MethodInfo_Property(MethodInfo_t *minfo) const;
	virtual TypeInfo_t MethodInfo_Type(MethodInfo_t minfo) const;	virtual TypeInfo_t MethodInfo_Type(MethodInfo_t minfo) const;
	virtual const char MethodInfo_GetMangledName(MethodInfo_t minfo) const ;	virtual const char MethodInfo_GetMangledName(MethodInfo_t minfo) const ;
	virtual const char MethodInfo_GetPrototype(MethodInfo_t minfo) const;	virtual const char MethodInfo_GetPrototype(MethodInfo_t minfo) const;
	virtual const char MethodInfo_Name(MethodInfo_t minfo) const;	virtual const char MethodInfo_Name(MethodInfo_t minfo) const;
	virtual const char MethodInfo_TypeName(MethodInfo_t minfo) const;	virtual const char MethodInfo_TypeName(MethodInfo_t minfo) const;

		virtual std::string MethodInfo_TypeNormalizedName(MethodInfo_t *minfo) c onst;
	virtual const char MethodInfo_Title(MethodInfo_t minfo) const;	virtual const char MethodInfo_Title(MethodInfo_t minfo) const;

	// G__MethodArgInfo interface	// G__MethodArgInfo interface
	virtual void MethodArgInfo_Delete(MethodArgInfo_t *marginfo) const;	virtual void MethodArgInfo_Delete(MethodArgInfo_t *marginfo) const;
	virtual MethodArgInfo_t *MethodArgInfo_Factory() const;	virtual MethodArgInfo_t *MethodArgInfo_Factory() const;
	virtual MethodArgInfo_t MethodArgInfo_FactoryCopy(MethodArgInfo_t mar ginfo) const;	virtual MethodArgInfo_t MethodArgInfo_FactoryCopy(MethodArgInfo_t mar ginfo) const;
	virtual Bool_t MethodArgInfo_IsValid(MethodArgInfo_t *marginfo) const;	virtual Bool_t MethodArgInfo_IsValid(MethodArgInfo_t *marginfo) const;
	virtual int MethodArgInfo_Next(MethodArgInfo_t *marginfo) const;	virtual int MethodArgInfo_Next(MethodArgInfo_t *marginfo) const;
	virtual Long_t MethodArgInfo_Property(MethodArgInfo_t *marginfo) const;	virtual Long_t MethodArgInfo_Property(MethodArgInfo_t *marginfo) const;
	virtual const char MethodArgInfo_DefaultValue(MethodArgInfo_t marginfo ) const;	virtual const char MethodArgInfo_DefaultValue(MethodArgInfo_t marginfo ) const;
	virtual const char MethodArgInfo_Name(MethodArgInfo_t marginfo) const;	virtual const char MethodArgInfo_Name(MethodArgInfo_t marginfo) const;
	virtual const char MethodArgInfo_TypeName(MethodArgInfo_t marginfo) co nst;	virtual const char MethodArgInfo_TypeName(MethodArgInfo_t marginfo) co nst;

		virtual std::string MethodArgInfo_TypeNormalizedName(MethodArgInfo_t *ma rginfo) const;

	// G__TypeInfo interface	// G__TypeInfo interface
	virtual void TypeInfo_Delete(TypeInfo_t *tinfo) const;	virtual void TypeInfo_Delete(TypeInfo_t *tinfo) const;
	virtual TypeInfo_t *TypeInfo_Factory() const;	virtual TypeInfo_t *TypeInfo_Factory() const;
	virtual TypeInfo_t TypeInfo_Factory(G__value /* value */) const;	virtual TypeInfo_t TypeInfo_Factory(G__value /* value */) const;
	virtual TypeInfo_t TypeInfo_FactoryCopy(TypeInfo_t /* tinfo */) const ;	virtual TypeInfo_t TypeInfo_FactoryCopy(TypeInfo_t /* tinfo */) const ;
	virtual void TypeInfo_Init(TypeInfo_t tinfo, const char funcname) co nst;	virtual void TypeInfo_Init(TypeInfo_t tinfo, const char funcname) co nst;
	virtual Bool_t TypeInfo_IsValid(TypeInfo_t *tinfo) const;	virtual Bool_t TypeInfo_IsValid(TypeInfo_t *tinfo) const;
	virtual const char TypeInfo_Name(TypeInfo_t /* info */) const;	virtual const char TypeInfo_Name(TypeInfo_t /* info */) const;
	virtual Long_t TypeInfo_Property(TypeInfo_t *tinfo) const;	virtual Long_t TypeInfo_Property(TypeInfo_t *tinfo) const;

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

	TEmulatedCollectionProxy.h	TEmulatedCollectionProxy.h

	// @(#)root/io:$Id: TEmulatedCollectionProxy.h 43271 2012-03-07 05:53:52Z p canal $	// @(#)root/io:$Id: TEmulatedCollectionProxy.h 49000 2013-03-29 10:47:59Z p canal $
	// 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_TEmulatedCollectionProxy	#ifndef ROOT_TEmulatedCollectionProxy

	skipping to change at line 87	skipping to change at line 87
	// Virtual in-place constructor	// Virtual in-place constructor
	virtual void* New(void* memory) const { return new(memory) Cont_t; }	virtual void* New(void* memory) const { return new(memory) Cont_t; }

	// Virtual array constructor	// Virtual array constructor
	virtual void* NewArray(Int_t nElements) const { return ne w Cont_t[nElements]; }	virtual void* NewArray(Int_t nElements) const { return ne w Cont_t[nElements]; }

	// Virtual in-place constructor	// Virtual in-place constructor
	virtual void* NewArray(Int_t nElements, void* memory) const { return new(memory) Cont_t[nElements]; }	virtual void* NewArray(Int_t nElements, void* memory) const { return new(memory) Cont_t[nElements]; }

	// Virtual destructor	// Virtual destructor

	virtual void Destructor(void* p, Bool_t dtorOnly = kFALSE);	virtual void Destructor(void* p, Bool_t dtorOnly = kFALSE) const;

	// Virtual array destructor	// Virtual array destructor

	virtual void DeleteArray(void* p, Bool_t dtorOnly = kFALSE);	virtual void DeleteArray(void* p, Bool_t dtorOnly = kFALSE) const;

	// TVirtualCollectionProxy overload: Return the sizeof the collection ob ject.	// TVirtualCollectionProxy overload: Return the sizeof the collection ob ject.
	virtual UInt_t Sizeof() const { return sizeof(Cont_t); }	virtual UInt_t Sizeof() const { return sizeof(Cont_t); }

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

	// Clear the container	// Clear the container
	virtual void Clear(const char *opt = "");	virtual void Clear(const char *opt = "");


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

	TFitEditor.h	TFitEditor.h

	// @(#)root/fitpanel:$Id: TFitEditor.h 39109 2011-05-05 13:06:38Z moneta $	// @(#)root/fitpanel:$Id: TFitEditor.h 48991 2013-03-28 15:25:11Z rdm $
	// Author: Ilka Antcheva, Lorenzo Moneta, David Gonzalez Maline 10/08/2006	// Author: Ilka Antcheva, Lorenzo Moneta, David Gonzalez Maline 10/08/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. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 134	skipping to change at line 134
	// structure holding parameter value and limits	// structure holding parameter value and limits
	struct FuncParamData_t {	struct FuncParamData_t {
	FuncParamData_t() {	FuncParamData_t() {
	fP[0] = 0; fP[1] = 0; fP[2] = 0;	fP[0] = 0; fP[1] = 0; fP[2] = 0;
	}	}
	Double_t & operator[](UInt_t i) { return fP[i];}	Double_t & operator[](UInt_t i) { return fP[i];}
	Double_t fP[3];	Double_t fP[3];
	};	};
	std::vector<FuncParamData_t> fFuncPars; // function parameters (value + limits)	std::vector<FuncParamData_t> fFuncPars; // function parameters (value + limits)


	std::multimap<TObject, TF1> fPrevFit; // Previous succesful fits.	std::multimap<TObject, TF1> fPrevFit; // Previous successful fits.
	std::vector<TF1*> fSystemFuncs; // functions managed by the fitp anel	std::vector<TF1*> fSystemFuncs; // functions managed by the fitp anel

	TGRadioButton *fLibMinuit; // set default minimization libr ary (Minuit)	TGRadioButton *fLibMinuit; // set default minimization libr ary (Minuit)
	TGRadioButton *fLibMinuit2; // set Minuit2 as minimization l ibrary	TGRadioButton *fLibMinuit2; // set Minuit2 as minimization l ibrary
	TGRadioButton *fLibFumili; // set Fumili as minimization li brary	TGRadioButton *fLibFumili; // set Fumili as minimization li brary
	TGRadioButton *fLibGSL; // set GSL as minimization libra ry	TGRadioButton *fLibGSL; // set GSL as minimization libra ry
	TGRadioButton *fLibGenetics; // set Genetic/GALib as minimiza tion library	TGRadioButton *fLibGenetics; // set Genetic/GALib as minimiza tion library
	TGComboBox *fMinMethodList; // set the minimization method	TGComboBox *fMinMethodList; // set the minimization method
	TGNumberEntryField *fErrorScale; // contains error scale set for minimization	TGNumberEntryField *fErrorScale; // contains error scale set for minimization
	TGNumberEntryField *fTolerance; // contains tolerance set for mi nimization	TGNumberEntryField *fTolerance; // contains tolerance set for mi nimization

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

	TFormLeafInfo.h	TFormLeafInfo.h

	// @(#)root/treeplayer:$Id: TFormLeafInfo.h 43286 2012-03-08 13:30:37Z pcan al $	// @(#)root/treeplayer:$Id: TFormLeafInfo.h 48991 2013-03-28 15:25:11Z rdm $
	// Author: Philippe Canal 01/06/2004	// Author: Philippe Canal 01/06/2004

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers and al. *	* Copyright (C) 1995-2000, 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 340	skipping to change at line 340
	virtual Bool_t IsString() const;	virtual Bool_t IsString() const;
	virtual Double_t ReadValue(char *where, Int_t instance = 0);	virtual Double_t ReadValue(char *where, Int_t instance = 0);
	virtual Bool_t Update();	virtual Bool_t Update();
	};	};

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

	// non-splitted object.	// non-split object.

	class TFormLeafInfoMultiVarDim : public TFormLeafInfo {	class TFormLeafInfoMultiVarDim : public TFormLeafInfo {
	public:	public:
	Int_t fNsize;	Int_t fNsize;
	TArrayI fSizes; // Array of sizes of the variable dimension	TArrayI fSizes; // Array of sizes of the variable dimension
	TFormLeafInfo *fCounter2; // Information on how to read the secondary di mensions	TFormLeafInfo *fCounter2; // Information on how to read the secondary di mensions
	Int_t fSumOfSizes; // Sum of the content of fSizes	Int_t fSumOfSizes; // Sum of the content of fSizes
	Int_t fDim; // physical number of the dimension that is va riable	Int_t fDim; // physical number of the dimension that is va riable
	Int_t fVirtDim; // number of the virtual dimension to which th is object correspond.	Int_t fVirtDim; // number of the virtual dimension to which th is object correspond.
	Int_t fPrimaryIndex; // Index of the dimensions that is indexing th e second dimension's size	Int_t fPrimaryIndex; // Index of the dimensions that is indexing th e second dimension's size

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

	TGHtml.h	TGHtml.h

	skipping to change at line 152	skipping to change at line 152

	// An instance of the following structure is used to record style	// An instance of the following structure is used to record style
	// information on each Html element.	// information on each Html element.

	struct SHtmlStyle_t {	struct SHtmlStyle_t {
	unsigned int fFont : 6; // Font to use for display	unsigned int fFont : 6; // Font to use for display
	unsigned int fColor : 6; // Foreground color	unsigned int fColor : 6; // Foreground color
	signed int fSubscript : 4; // Positive for <sup>, negative for <su b>	signed int fSubscript : 4; // Positive for <sup>, negative for <su b>
	unsigned int fAlign : 2; // Horizontal alignment	unsigned int fAlign : 2; // Horizontal alignment
	unsigned int fBgcolor : 6; // Background color	unsigned int fBgcolor : 6; // Background color

	unsigned int fExpbg : 1; // Set to 1 if bgcolor explicitely set	unsigned int fExpbg : 1; // Set to 1 if bgcolor explicitly set
	unsigned int fFlags : 7; // the STY_ flags below	unsigned int fFlags : 7; // the STY_ flags below
	};	};

	// We allow 8 different font families: Normal, Bold, Italic and Bold-Italic	// We allow 8 different font families: Normal, Bold, Italic and Bold-Italic
	// in either variable or constant width. Within each family there can be up	// in either variable or constant width. Within each family there can be up
	// to 7 font sizes from 1 (the smallest) up to 7 (the largest). Hence, the	// to 7 font sizes from 1 (the smallest) up to 7 (the largest). Hence, the
	// widget can use a maximum of 56 fonts. The ".font" field of the style is	// widget can use a maximum of 56 fonts. The ".font" field of the style is
	// an integer between 0 and 55 which indicates which font to use.	// an integer between 0 and 55 which indicates which font to use.

	// HP: we further subdivide the .font field into two 3-bit subfields (size	// HP: we further subdivide the .font field into two 3-bit subfields (size

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

	TGLUtil.h	TGLUtil.h

	// @(#)root/gl:$Id: TGLUtil.h 47130 2012-11-09 03:05:52Z matevz $	// @(#)root/gl:$Id: TGLUtil.h 49071 2013-04-04 05:21:42Z 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 133	skipping to change at line 133
	Double_t Y() const { return fVals[1]; }	Double_t Y() const { return fVals[1]; }
	Double_t & Y() { return fVals[1]; }	Double_t & Y() { return fVals[1]; }
	Double_t Z() const { return fVals[2]; }	Double_t Z() const { return fVals[2]; }
	Double_t & Z() { return fVals[2]; }	Double_t & Z() { return fVals[2]; }

	const Double_t * CArr() const { return fVals; }	const Double_t * CArr() const { return fVals; }
	Double_t * Arr() { return fVals; }	Double_t * Arr() { return fVals; }

	void Dump() const;	void Dump() const;


	ClassDef(TGLVertex3,0); // GL 3 component vertex helper/wrapper class	ClassDef(TGLVertex3,1); // GL 3 component vertex helper/wrapper class
	};	};

	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	inline TGLVertex3 operator*(Double_t f, const TGLVertex3& v)	inline TGLVertex3 operator*(Double_t f, const TGLVertex3& v)
	{	{
	return TGLVertex3(fv.X(), fv.Y(), f*v.Z());	return TGLVertex3(fv.X(), fv.Y(), f*v.Z());
	}	}

	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	inline void TGLVertex3::Negate()	inline void TGLVertex3::Negate()

	skipping to change at line 266	skipping to change at line 266

	TGLVector3& operator = (const TGLVertex3& v)	TGLVector3& operator = (const TGLVertex3& v)
	{ fVals[0] = v[0]; fVals[1] = v[1]; fVals[2] = v[2]; return *this; }	{ fVals[0] = v[0]; fVals[1] = v[1]; fVals[2] = v[2]; return *this; }

	TGLVector3 & operator /= (Double_t val);	TGLVector3 & operator /= (Double_t val);
	TGLVector3 operator - () const;	TGLVector3 operator - () const;

	Double_t Mag() const;	Double_t Mag() const;
	void Normalise();	void Normalise();


	ClassDef(TGLVector3,0); // GL 3 component vector helper/wrapper class	ClassDef(TGLVector3,1); // GL 3 component vector helper/wrapper class
	};	};

	// Inline for TGLVertex3 requiring full TGLVector definition	// Inline for TGLVertex3 requiring full TGLVector definition
	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	inline const TGLVertex3 & TGLVertex3::operator -= (const TGLVector3 & vec)	inline const TGLVertex3 & TGLVertex3::operator -= (const TGLVector3 & vec)
	{	{
	fVals[0] -= vec[0]; fVals[1] -= vec[1]; fVals[2] -= vec[2];	fVals[0] -= vec[0]; fVals[1] -= vec[1]; fVals[2] -= vec[2];
	return *this;	return *this;
	}	}


	skipping to change at line 669	skipping to change at line 669
	TGLVector3 Rotate(const TGLVector3& v) const;	TGLVector3 Rotate(const TGLVector3& v) const;
	void MultiplyIP(TGLVector3& v, Double_t w=1) const;	void MultiplyIP(TGLVector3& v, Double_t w=1) const;
	void RotateIP(TGLVector3& v) const;	void RotateIP(TGLVector3& v) const;

	// Internal data accessors - for GL API	// Internal data accessors - for GL API
	const Double_t * CArr() const { return fVals; }	const Double_t * CArr() const { return fVals; }
	Double_t * Arr() { return fVals; }	Double_t * Arr() { return fVals; }

	void Dump() const;	void Dump() const;


	ClassDef(TGLMatrix,0); // GL matrix helper/wrapper class	ClassDef(TGLMatrix,1); // GL matrix helper/wrapper class
	};	};

	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	inline TGLMatrix & TGLMatrix::operator =(const TGLMatrix & rhs)	inline TGLMatrix & TGLMatrix::operator =(const TGLMatrix & rhs)
	{	{
	// Check for self-assignment	// Check for self-assignment
	if (this != &rhs) {	if (this != &rhs) {
	Set(rhs.fVals);	Set(rhs.fVals);
	}	}
	return *this;	return *this;

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