diff --git a/README/ReleaseNotes/v642/index.md b/README/ReleaseNotes/v642/index.md
index 7056c9453b14b..eb3d328410074 100644
--- a/README/ReleaseNotes/v642/index.md
+++ b/README/ReleaseNotes/v642/index.md
@@ -76,6 +76,7 @@ The `TMVA_SOFIE_GNN` tutorials have been migrated to this workflow and produce i
 * Including `RConfig.h` and `RVersion.h` is now deprecated and will be removed after ROOT 6.44, use instead `ROOT/RConfig.hxx` and `ROOT/RVersion.hxx`.
 * The header `Rpair.h` is deprecated and will be removed after ROOT 6.44, use `<utility>` instead.
 * The header `Hparam.h` and `Hoption.h` are now deprecated and will be removed in ROOT 6.44, use instead `THistPainter`, `TGraph2DPainter` public interfaces.
+* The legacy headers `v5/TF1Data.h`, `v5/TFormula.h` and `v5/TFormulaPrimitive.h` have been moved to `ROOT/v5/TF1Data.h`, `ROOT/v5/TFormula.h` and `ROOT/v5/TFormulaPrimitive.h`. Including them as before will now raise warnings and will be no longer supported in ROOT 6.44.
 * The headers `Htypes.h` and `Gtypes.h` that were deprecated in ROOT 6.20 will now emit warnings and will be fully removed in ROOT 6.44. Use instead `Rtypes.h`.
 * The header `GLConstants.h` is no longer part of ROOT installed headers.
 * The header `Bswapcpy.h` is deprecated and will be removed from the public interface after ROOT 6.44, it's an implementation detail for Unix i386 GNUC used by TBufferFile.
diff --git a/hist/hist/CMakeLists.txt b/hist/hist/CMakeLists.txt
index d3b4610c72342..2993d637092d8 100644
--- a/hist/hist/CMakeLists.txt
+++ b/hist/hist/CMakeLists.txt
@@ -93,9 +93,9 @@ ROOT_STANDARD_LIBRARY_PACKAGE(Hist
     TVirtualPaveStats.h
     Math/WrappedMultiTF1.h
     Math/WrappedTF1.h
-    v5/TF1Data.h
-    v5/TFormula.h
-    v5/TFormulaPrimitive.h
+    ROOT/v5/TF1Data.h
+    ROOT/v5/TFormula.h
+    ROOT/v5/TFormulaPrimitive.h
   SOURCES
     AnalyticalIntegrals.cxx
     Haxis.cxx
diff --git a/hist/hist/inc/ROOT/v5/TF1Data.h b/hist/hist/inc/ROOT/v5/TF1Data.h
new file mode 100644
index 0000000000000..1a9e4eef993e1
--- /dev/null
+++ b/hist/hist/inc/ROOT/v5/TF1Data.h
@@ -0,0 +1,66 @@
+// @(#)root/hist:$Id$
+// Author: Rene Brun   18/08/95
+
+/*************************************************************************
+ * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
+ * All rights reserved.                                                  *
+ *                                                                       *
+ * For the licensing terms see $ROOTSYS/LICENSE.                         *
+ * For the list of contributors see $ROOTSYS/README/CREDITS.             *
+ *************************************************************************/
+
+
+#ifndef ROOT_v5_TF1DATA
+#define ROOT_v5_TF1DATA
+
+
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// TF1Data                                                                 //
+//                                                                      //
+// Dummy class with same structure of v5::TF1 objects
+// used only for reading the old files                                   //
+//////////////////////////////////////////////////////////////////////////
+
+#include "RConfigure.h"
+
+#include "ROOT/v5/TFormula.h"
+#include "TAttLine.h"
+#include "TAttFill.h"
+#include "TAttMarker.h"
+
+namespace ROOT {
+
+   namespace v5 {
+
+struct TF1Data : public ROOT::v5::TFormula, public TAttLine, public TAttFill, public TAttMarker {
+
+   Double_t    fXmin;        //Lower bounds for the range
+   Double_t    fXmax;        //Upper bounds for the range
+   Int_t       fNpx;         //Number of points used for the graphical representation
+   Int_t       fType;        //(=0 for standard functions, 1 if pointer to function)
+   Int_t       fNpfits;      //Number of points used in the fit
+   Int_t       fNDF;         //Number of degrees of freedom in the fit
+   Int_t       fNsave;       //Number of points used to fill array fSave
+   Double_t    fChisquare;   //Function fit chisquare
+   Double_t    *fParErrors;  //[fNpar] Array of errors of the fNpar parameters
+   Double_t    *fParMin;     //[fNpar] Array of lower limits of the fNpar parameters
+   Double_t    *fParMax;     //[fNpar] Array of upper limits of the fNpar parameters
+   Double_t    *fSave;       //[fNsave] Array of fNsave function values
+   Double_t     fMaximum;    //Maximum value for plotting
+   Double_t     fMinimum;    //Minimum value for plotting
+
+
+
+   TF1Data();
+     ~TF1Data() override;
+   void Streamer(TBuffer &b, Int_t version, UInt_t start, UInt_t count, const TClass *onfile_class = nullptr);
+
+   ClassDefOverride(TF1Data,7)  //The Parametric 1-D function data structure  of v5::TF1
+};
+
+   }  // end namespace v5
+}   // end namespace ROOT
+
+#endif
diff --git a/hist/hist/inc/ROOT/v5/TFormula.h b/hist/hist/inc/ROOT/v5/TFormula.h
new file mode 100644
index 0000000000000..c25b744b41e1c
--- /dev/null
+++ b/hist/hist/inc/ROOT/v5/TFormula.h
@@ -0,0 +1,279 @@
+// @(#)root/hist:$Id$
+// Author: Nicolas Brun   19/08/95
+
+/*************************************************************************
+ * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
+ * All rights reserved.                                                  *
+ *                                                                       *
+ * For the licensing terms see $ROOTSYS/LICENSE.                         *
+ * For the list of contributors see $ROOTSYS/README/CREDITS.             *
+ *************************************************************************/
+// ---------------------------------- Formula.h
+
+#ifndef ROOT_v5_TFormula
+#define ROOT_v5_TFormula
+
+
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// TFormula                                                             //
+//                                                                      //
+// The old formula base class  f(x,y,z,par)                             //
+// mantained for backward compatibility and TTree usage                 //
+//////////////////////////////////////////////////////////////////////////
+
+#include "TNamed.h"
+#include "TBits.h"
+#include "TObjArray.h"
+
+
+const Int_t kMAXFOUND = 500;
+const Int_t kTFOperMask = 0x7fffff;
+const UChar_t kTFOperShift = 23;
+
+
+
+namespace ROOT {
+   namespace v5 {
+
+     class TFormulaPrimitive;
+
+class  TOperOffset {
+   friend class TFormula;
+public:
+   enum {
+      kVariable  = 0,
+      kParameter = 1,
+      kConstant  = 2
+   };
+   TOperOffset();
+protected:
+   Short_t fType0;            // type     of operand  0
+   Short_t fOffset0;          // offset   of operand  0
+   Short_t fType1;            // type     of operand  1
+   Short_t fOffset1;          // offset   of operand  1
+   Short_t fType2;            // type     of operand  2
+   Short_t fOffset2;          // offset   of operand  2
+   Short_t fType3;            // type     of operand  3
+   Short_t fOffset3;          // offset   of operand  3
+   Short_t fToJump;           // where to jump in case of optimized boolen
+   Short_t fOldAction;        // temporary variable used during optimization
+};
+
+
+class TFormula : public TNamed {
+
+protected:
+
+   typedef Double_t (TObject::*TFuncG)(const Double_t*,const Double_t*) const;
+
+   Int_t      fNdim;            //Dimension of function (1=1-Dim, 2=2-Dim,etc)
+   Int_t      fNpar;            //Number of parameters
+   Int_t      fNoper;           //Number of operators
+   Int_t      fNconst;          //Number of constants
+   Int_t      fNumber;          //formula number identifier
+   Int_t      fNval;            //Number of different variables in expression
+   Int_t      fNstring;         //Number of different constants character strings
+   TString   *fExpr;            //[fNoper] List of expressions
+private:
+   Int_t     *fOper;            //[fNoper] List of operators. (See documentation for changes made at version 7)
+protected:
+   Double_t  *fConst;           //[fNconst] Array of fNconst formula constants
+   Double_t  *fParams;          //[fNpar] Array of fNpar parameters
+   TString   *fNames;           //[fNpar] Array of parameter names
+   TObjArray  fFunctions;       //Array of function calls to make
+   TObjArray  fLinearParts;     //Linear parts if the formula is linear (contains '|' or "++")
+
+   TBits      fAlreadyFound;    ///<! cache for information
+
+   // Optimized expression
+   Int_t                fNOperOptimized; ///<!Number of operators after optimization
+   TString             *fExprOptimized;  ///<![fNOperOptimized] List of expressions
+   Int_t               *fOperOptimized;  ///<![fNOperOptimized] List of operators. (See documentation for changes made at version 7)
+   TOperOffset         *fOperOffset;     ///<![fNOperOptimized]         Offsets of operrands
+   TFormulaPrimitive  **fPredefined;      ///<![fNPar] predefined function
+   TFuncG               fOptimal; ///<!pointer to optimal function
+
+   Int_t             PreCompile();
+   virtual Bool_t    AnalyzePrimitive(TString &chain, TObjArray &args, Int_t &err, Int_t offset);
+   virtual Bool_t    CheckOperands(Int_t operation, Int_t &err);
+   virtual Bool_t    CheckOperands(Int_t leftoperand, Int_t rightoperartion, Int_t &err);
+   virtual Bool_t    StringToNumber(Int_t code);
+   void              MakePrimitive(const char *expr, Int_t pos);
+   inline Int_t     *GetOper() const { return fOper; }
+   inline Short_t    GetAction(Int_t code) const { return fOper[code] >> kTFOperShift; }
+   inline Int_t      GetActionParam(Int_t code) const { return fOper[code] & kTFOperMask; }
+
+   inline void       SetAction(Int_t code, Int_t value, Int_t param = 0) {
+      fOper[code]  = (value) << kTFOperShift;
+      fOper[code] += param;
+   }
+   inline Int_t     *GetOperOptimized() const { return fOperOptimized; }
+   inline Short_t    GetActionOptimized(Int_t code) const { return fOperOptimized[code] >> kTFOperShift; }
+   inline Int_t      GetActionParamOptimized(Int_t code) const { return fOperOptimized[code] & kTFOperMask; }
+
+   inline void       SetActionOptimized(Int_t code, Int_t value, Int_t param = 0) {
+      fOperOptimized[code]  = (value) << kTFOperShift;
+      fOperOptimized[code] += param;
+   }
+
+   void            ClearFormula(Option_t *option="");
+   virtual Bool_t  IsString(Int_t oper) const;
+
+   virtual void    Convert(UInt_t fromVersion);
+   //
+   // Functions  - used for formula evaluation
+   Double_t        EvalParFast(const Double_t *x, const Double_t *params);
+   Double_t        EvalPrimitive(const Double_t *x, const Double_t *params);
+   Double_t        EvalPrimitive0(const Double_t *x, const Double_t *params);
+   Double_t        EvalPrimitive1(const Double_t *x, const Double_t *params);
+   Double_t        EvalPrimitive2(const Double_t *x, const Double_t *params);
+   Double_t        EvalPrimitive3(const Double_t *x, const Double_t *params);
+   Double_t        EvalPrimitive4(const Double_t *x, const Double_t *params);
+
+   // Action code for Version 6 and above.
+   enum {
+      kEnd      = 0,
+      kAdd      = 1, kSubstract = 2,
+      kMultiply = 3, kDivide    = 4,
+      kModulo   = 5,
+
+      kcos      = 10, ksin  = 11 , ktan  = 12,
+      kacos     = 13, kasin = 14 , katan = 15,
+      katan2    = 16,
+      kfmod     = 17,
+
+      kpow      = 20, ksq = 21, ksqrt     = 22,
+
+      kstrstr   = 23,
+
+      kmin      = 24, kmax = 25,
+
+      klog      = 30, kexp = 31, klog10 = 32,
+
+      kpi     = 40,
+
+      kabs    = 41 , ksign= 42,
+      kint    = 43 ,
+      kSignInv= 44 ,
+      krndm   = 50 ,
+
+      kAnd      = 60, kOr          = 61,
+      kEqual    = 62, kNotEqual    = 63,
+      kLess     = 64, kGreater     = 65,
+      kLessThan = 66, kGreaterThan = 67,
+      kNot      = 68,
+
+      kcosh   = 70 , ksinh  = 71, ktanh  = 72,
+      kacosh  = 73 , kasinh = 74, katanh = 75,
+
+      kStringEqual = 76, kStringNotEqual = 77,
+
+      kBitAnd    = 78, kBitOr     = 79,
+      kLeftShift = 80, kRightShift = 81,
+
+      kJumpIf = 82, kJump = 83,
+
+      kexpo   = 100 , kxexpo   = 100, kyexpo   = 101, kzexpo   = 102, kxyexpo   = 105,
+      kgaus   = 110 , kxgaus   = 110, kygaus   = 111, kzgaus   = 112, kxygaus   = 115,
+      klandau = 120 , kxlandau = 120, kylandau = 121, kzlandau = 122, kxylandau = 125,
+      kpol    = 130 , kxpol    = 130, kypol    = 131, kzpol    = 132,
+
+      kParameter       = 140,
+      kConstant        = 141,
+      kBoolOptimize    = 142,
+      kStringConst     = 143,
+      kVariable        = 144,
+      kFunctionCall    = 145,
+      kData            = 146,
+      kUnary           = 147,
+      kBinary          = 148,
+      kThree           = 149,
+      kDefinedVariable = 150,
+      kDefinedString   = 151,
+      //
+      kPlusD           = 152,
+      kPlusDD          = 153,
+      kMultD           = 154,
+      kMultDD          = 155,
+      kBoolOptimizeOr  = 156,
+      kBoolOptimizeAnd = 157,
+      kBoolSet         = 158,
+      kFDM             = 159,
+      kFD0             = 160,
+      kFD1             = 161,
+      kFD2             = 162,
+      kFD3             = 163
+   };
+
+public:
+   // TFormula status bits
+   enum {
+      kNotGlobal     = BIT(10),  // don't store in gROOT->GetListOfFunction
+      kNormalized    = BIT(14),   // set to true if the function (ex gausn) is normalized
+      kLinear        = BIT(16)    //set to true if the function is for linear fitting
+   };
+
+               TFormula();
+               TFormula(const char *name,const char *formula);
+               TFormula(const TFormula &formula);
+   TFormula&   operator=(const TFormula &rhs);
+      ~TFormula() override;
+
+ public:
+   virtual void        Optimize();
+   virtual void        Analyze(const char *schain, Int_t &err, Int_t offset=0);
+   virtual Bool_t      AnalyzeFunction(TString &chaine, Int_t &err, Int_t offset=0);
+   virtual Int_t       Compile(const char *expression="");
+   void        Copy(TObject &formula) const override;
+   void        Clear(Option_t *option="") override;
+   virtual char       *DefinedString(Int_t code);
+   virtual Double_t    DefinedValue(Int_t code);
+   virtual Int_t       DefinedVariable(TString &variable,Int_t &action);
+   virtual Double_t    Eval(Double_t x, Double_t y=0, Double_t z=0, Double_t t=0) const;
+   virtual Double_t    EvalParOld(const Double_t *x, const Double_t *params=nullptr);
+   virtual Double_t    EvalPar(const Double_t *x, const Double_t *params=nullptr){return ((*this).*fOptimal)(x,params);};
+   virtual const TObject *GetLinearPart(Int_t i);
+   virtual Int_t       GetNdim() const {return fNdim;}
+   virtual Int_t       GetNpar() const {return fNpar;}
+   virtual Int_t       GetNumber() const {return fNumber;}
+   virtual TString     GetExpFormula(Option_t *option = "") const;
+   Double_t            GetParameter(Int_t ipar) const;
+   Double_t            GetParameter(const char *name) const;
+   virtual Double_t   *GetParameters() const {return fParams;}
+   virtual void        GetParameters(Double_t *params){for(Int_t i=0;i<fNpar;i++) params[i] = fParams[i];}
+   virtual const char *GetParName(Int_t ipar) const;
+   virtual Int_t       GetParNumber(const char *name) const;
+   virtual Bool_t      IsLinear() const {return TestBit(kLinear);}
+   virtual Bool_t      IsNormalized() const {return TestBit(kNormalized);}
+   void        Print(Option_t *option="") const override; // *MENU*
+   virtual void        ProcessLinear(TString &replaceformula);
+   virtual void        SetNumber(Int_t number) {fNumber = number;}
+   virtual void        SetParameter(const char *name, Double_t parvalue);
+   virtual void        SetParameter(Int_t ipar, Double_t parvalue);
+   virtual void        SetParameters(const Double_t *params);
+   virtual void        SetParameters(Double_t p0,Double_t p1,Double_t p2=0,Double_t p3=0,Double_t p4=0,
+                                     Double_t p5=0,Double_t p6=0,Double_t p7=0,Double_t p8=0,
+                                     Double_t p9=0,Double_t p10=0); // *MENU*
+   virtual void        SetParName(Int_t ipar, const char *name);
+   virtual void        SetParNames(const char *name0="p0",const char *name1="p1",const char
+                                   *name2="p2",const char *name3="p3",const char
+                                   *name4="p4", const char *name5="p5",const char *name6="p6",const char *name7="p7",const char
+                                   *name8="p8",const char *name9="p9",const char *name10="p10"); // *MENU*
+   virtual void        Update() {}
+
+   static  void        SetMaxima(Int_t maxop=1000, Int_t maxpar=1000, Int_t maxconst=1000);
+   static  void        GetMaxima(Int_t& maxop, Int_t& maxpar, Int_t& maxconst);
+
+   void Streamer(TBuffer &b, const TClass *onfile_class);
+   void Streamer(TBuffer &b, Int_t version, UInt_t start, UInt_t count, const TClass *onfile_class = nullptr);
+
+   ClassDefOverride(ROOT::v5::TFormula,8)  //The formula base class  f(x,y,z,par)
+};
+
+   } // end namespace v5
+
+} // end namespace ROOT
+
+#endif
diff --git a/hist/hist/inc/ROOT/v5/TFormulaPrimitive.h b/hist/hist/inc/ROOT/v5/TFormulaPrimitive.h
new file mode 100644
index 0000000000000..78602169129cc
--- /dev/null
+++ b/hist/hist/inc/ROOT/v5/TFormulaPrimitive.h
@@ -0,0 +1,101 @@
+// @(#)root/hist:$Id$
+// Author: Marian Ivanov, 2005
+
+/*************************************************************************
+* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
+* All rights reserved.                                                  *
+*                                                                       *
+* For the licensing terms see $ROOTSYS/LICENSE.                         *
+* For the list of contributors see $ROOTSYS/README/CREDITS.             *
+*************************************************************************/
+// ---------------------------------- TFormulaPrimitive.h
+
+#ifndef ROOT_v5_TFormulaPrimitive
+#define ROOT_v5_TFormulaPrimitive
+
+
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// TFormulaPrimitive                                                    //
+//                                                                      //
+// The formula primitive base class                                     //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#include "TNamed.h"
+#include "TBits.h"
+
+class TObjArray;
+
+namespace ROOT {
+
+   namespace v5 {
+
+class TFormula;
+
+class TFormulaPrimitive : public TNamed
+{
+   friend class ROOT::v5::TFormula;
+public:
+   typedef Double_t (*GenFuncG)(const Double_t*,const Double_t*);
+   typedef Double_t (*GenFunc0)();
+   typedef Double_t (*GenFunc10)(Double_t);
+   typedef Double_t (*GenFunc110)(Double_t,Double_t);
+   typedef Double_t (*GenFunc1110)(Double_t,Double_t, Double_t);
+   typedef Double_t (TObject::*TFuncG)(const Double_t*,const Double_t*) const;
+   typedef Double_t (TObject::*TFunc0)() const;
+   typedef Double_t (TObject::*TFunc10)(Double_t) const;
+   typedef Double_t (TObject::*TFunc110)(Double_t,Double_t) const;
+   typedef Double_t (TObject::*TFunc1110)(Double_t,Double_t,Double_t) const;
+protected:
+   static TObjArray * fgListOfFunction;                   ///<!list of global primitive formulas
+   static Int_t       BuildBasicFormulas();               //build list of basic formulas
+   union {
+      GenFuncG    fFuncG;                                 ///<!pointer to the TFormula generic function
+      GenFunc0    fFunc0;                                 ///<!pointer to the function
+      GenFunc10   fFunc10;                                ///<!pointer to the function
+      GenFunc110  fFunc110;                               ///<!pointer to the function
+      GenFunc1110 fFunc1110;                              ///<!pointer to the function
+      TFuncG      fTFuncG;                                ///<!pointer to the TFormula generic function
+      TFunc0      fTFunc0;                                ///<! pointer to member function
+      TFunc10     fTFunc10;                               ///<! pointer to member function
+      TFunc110    fTFunc110;                              ///<! pointer to member function
+      TFunc1110   fTFunc1110;                             ///<! pointer to member function
+   };
+   Int_t      fType;                                      //type of the function
+   Int_t      fNArguments;                                //number of arguments
+   Int_t      fNParameters;                               //number of parameters
+   Bool_t     fIsStatic;                                  // indication if the function is static
+private:
+   TFormulaPrimitive(const TFormulaPrimitive&) = delete;
+   TFormulaPrimitive& operator=(const TFormulaPrimitive&) = delete;
+public:
+   TFormulaPrimitive();
+   TFormulaPrimitive(const char *name,const char *formula, GenFunc0 fpointer);
+   TFormulaPrimitive(const char *name,const char *formula, GenFunc10 fpointer);
+   TFormulaPrimitive(const char *name,const char *formula, GenFunc110 fpointer);
+   TFormulaPrimitive(const char *name,const char *formula, GenFunc1110 fpointer);
+   TFormulaPrimitive(const char *name,const char *formula, GenFuncG fpointer,Int_t npar);
+   TFormulaPrimitive(const char *name,const char *formula, TFunc0 fpointer);
+   TFormulaPrimitive(const char *name,const char *formula, TFunc10 fpointer);
+   TFormulaPrimitive(const char *name,const char *formula, TFunc110 fpointer);
+   TFormulaPrimitive(const char *name,const char *formula, TFunc1110 fpointer);
+   TFormulaPrimitive(const char *name,const char *formula, TFuncG fpointer);
+   static Int_t AddFormula(TFormulaPrimitive * formula);
+   static TFormulaPrimitive* FindFormula(const char* name);
+   static TFormulaPrimitive* FindFormula(const char* name, const char *args);
+   static TFormulaPrimitive* FindFormula(const char* name, UInt_t nargs);
+   Double_t Eval(Double_t* x);                   //eval primitive function
+   Double_t Eval(TObject *o,  Double_t *x);      //eval member function
+   Double_t Eval(Double_t *x, Double_t *param);  //eval primitive parametric function
+
+   ClassDefOverride(ROOT::v5::TFormulaPrimitive,0)  //The primitive formula
+};
+
+   } // end namespace v5
+
+} // end namespace ROOT
+
+
+#endif
diff --git a/hist/hist/inc/v5/TF1Data.h b/hist/hist/inc/v5/TF1Data.h
index db4765c4e688a..d26d2505a8690 100644
--- a/hist/hist/inc/v5/TF1Data.h
+++ b/hist/hist/inc/v5/TF1Data.h
@@ -1,66 +1,10 @@
-// @(#)root/hist:$Id$
-// Author: Rene Brun   18/08/95
+#ifndef ROOT_v5_TF1Data_fwd
+#define ROOT_v5_TF1Data_fwd
 
-/*************************************************************************
- * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
- * All rights reserved.                                                  *
- *                                                                       *
- * For the licensing terms see $ROOTSYS/LICENSE.                         *
- * For the list of contributors see $ROOTSYS/README/CREDITS.             *
- *************************************************************************/
+#include "ROOT/v5/TF1Data.h"
 
-
-#ifndef ROOT_v5_TF1DATA
-#define ROOT_v5_TF1DATA
-
-
-
-//////////////////////////////////////////////////////////////////////////
-//                                                                      //
-// TF1Data                                                                 //
-//                                                                      //
-// Dummy class with same structure of v5::TF1 objects
-// used only for reading the old files                                   //
-//////////////////////////////////////////////////////////////////////////
-
-#include "RConfigure.h"
-
-#include "v5/TFormula.h"
-#include "TAttLine.h"
-#include "TAttFill.h"
-#include "TAttMarker.h"
-
-namespace ROOT {
-
-   namespace v5 {
-
-struct TF1Data : public ROOT::v5::TFormula, public TAttLine, public TAttFill, public TAttMarker {
-
-   Double_t    fXmin;        //Lower bounds for the range
-   Double_t    fXmax;        //Upper bounds for the range
-   Int_t       fNpx;         //Number of points used for the graphical representation
-   Int_t       fType;        //(=0 for standard functions, 1 if pointer to function)
-   Int_t       fNpfits;      //Number of points used in the fit
-   Int_t       fNDF;         //Number of degrees of freedom in the fit
-   Int_t       fNsave;       //Number of points used to fill array fSave
-   Double_t    fChisquare;   //Function fit chisquare
-   Double_t    *fParErrors;  //[fNpar] Array of errors of the fNpar parameters
-   Double_t    *fParMin;     //[fNpar] Array of lower limits of the fNpar parameters
-   Double_t    *fParMax;     //[fNpar] Array of upper limits of the fNpar parameters
-   Double_t    *fSave;       //[fNsave] Array of fNsave function values
-   Double_t     fMaximum;    //Maximum value for plotting
-   Double_t     fMinimum;    //Minimum value for plotting
-
-
-
-   TF1Data();
-     ~TF1Data() override;
-   void Streamer(TBuffer &b, Int_t version, UInt_t start, UInt_t count, const TClass *onfile_class = nullptr);
-
-   ClassDefOverride(TF1Data,7)  //The Parametric 1-D function data structure  of v5::TF1
-};
-
-   }  // end namespace v5
-}   // end namespace ROOT
+#ifndef G__DICTIONARY
+#warning "v5 legacy header has been moved to ROOT subfolder. This header is deprecated and will be removed in ROOT 6.44.  Use 'ROOT/v5/TF1Data.h'."
+#endif
 
 #endif
diff --git a/hist/hist/inc/v5/TFormula.h b/hist/hist/inc/v5/TFormula.h
index c25b744b41e1c..86a594486eec6 100644
--- a/hist/hist/inc/v5/TFormula.h
+++ b/hist/hist/inc/v5/TFormula.h
@@ -1,279 +1,10 @@
-// @(#)root/hist:$Id$
-// Author: Nicolas Brun   19/08/95
+#ifndef ROOT_v5_TFormula_fwd
+#define ROOT_v5_TFormula_fwd
 
-/*************************************************************************
- * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
- * All rights reserved.                                                  *
- *                                                                       *
- * For the licensing terms see $ROOTSYS/LICENSE.                         *
- * For the list of contributors see $ROOTSYS/README/CREDITS.             *
- *************************************************************************/
-// ---------------------------------- Formula.h
+#include "ROOT/v5/TFormula.h"
 
-#ifndef ROOT_v5_TFormula
-#define ROOT_v5_TFormula
-
-
-
-//////////////////////////////////////////////////////////////////////////
-//                                                                      //
-// TFormula                                                             //
-//                                                                      //
-// The old formula base class  f(x,y,z,par)                             //
-// mantained for backward compatibility and TTree usage                 //
-//////////////////////////////////////////////////////////////////////////
-
-#include "TNamed.h"
-#include "TBits.h"
-#include "TObjArray.h"
-
-
-const Int_t kMAXFOUND = 500;
-const Int_t kTFOperMask = 0x7fffff;
-const UChar_t kTFOperShift = 23;
-
-
-
-namespace ROOT {
-   namespace v5 {
-
-     class TFormulaPrimitive;
-
-class  TOperOffset {
-   friend class TFormula;
-public:
-   enum {
-      kVariable  = 0,
-      kParameter = 1,
-      kConstant  = 2
-   };
-   TOperOffset();
-protected:
-   Short_t fType0;            // type     of operand  0
-   Short_t fOffset0;          // offset   of operand  0
-   Short_t fType1;            // type     of operand  1
-   Short_t fOffset1;          // offset   of operand  1
-   Short_t fType2;            // type     of operand  2
-   Short_t fOffset2;          // offset   of operand  2
-   Short_t fType3;            // type     of operand  3
-   Short_t fOffset3;          // offset   of operand  3
-   Short_t fToJump;           // where to jump in case of optimized boolen
-   Short_t fOldAction;        // temporary variable used during optimization
-};
-
-
-class TFormula : public TNamed {
-
-protected:
-
-   typedef Double_t (TObject::*TFuncG)(const Double_t*,const Double_t*) const;
-
-   Int_t      fNdim;            //Dimension of function (1=1-Dim, 2=2-Dim,etc)
-   Int_t      fNpar;            //Number of parameters
-   Int_t      fNoper;           //Number of operators
-   Int_t      fNconst;          //Number of constants
-   Int_t      fNumber;          //formula number identifier
-   Int_t      fNval;            //Number of different variables in expression
-   Int_t      fNstring;         //Number of different constants character strings
-   TString   *fExpr;            //[fNoper] List of expressions
-private:
-   Int_t     *fOper;            //[fNoper] List of operators. (See documentation for changes made at version 7)
-protected:
-   Double_t  *fConst;           //[fNconst] Array of fNconst formula constants
-   Double_t  *fParams;          //[fNpar] Array of fNpar parameters
-   TString   *fNames;           //[fNpar] Array of parameter names
-   TObjArray  fFunctions;       //Array of function calls to make
-   TObjArray  fLinearParts;     //Linear parts if the formula is linear (contains '|' or "++")
-
-   TBits      fAlreadyFound;    ///<! cache for information
-
-   // Optimized expression
-   Int_t                fNOperOptimized; ///<!Number of operators after optimization
-   TString             *fExprOptimized;  ///<![fNOperOptimized] List of expressions
-   Int_t               *fOperOptimized;  ///<![fNOperOptimized] List of operators. (See documentation for changes made at version 7)
-   TOperOffset         *fOperOffset;     ///<![fNOperOptimized]         Offsets of operrands
-   TFormulaPrimitive  **fPredefined;      ///<![fNPar] predefined function
-   TFuncG               fOptimal; ///<!pointer to optimal function
-
-   Int_t             PreCompile();
-   virtual Bool_t    AnalyzePrimitive(TString &chain, TObjArray &args, Int_t &err, Int_t offset);
-   virtual Bool_t    CheckOperands(Int_t operation, Int_t &err);
-   virtual Bool_t    CheckOperands(Int_t leftoperand, Int_t rightoperartion, Int_t &err);
-   virtual Bool_t    StringToNumber(Int_t code);
-   void              MakePrimitive(const char *expr, Int_t pos);
-   inline Int_t     *GetOper() const { return fOper; }
-   inline Short_t    GetAction(Int_t code) const { return fOper[code] >> kTFOperShift; }
-   inline Int_t      GetActionParam(Int_t code) const { return fOper[code] & kTFOperMask; }
-
-   inline void       SetAction(Int_t code, Int_t value, Int_t param = 0) {
-      fOper[code]  = (value) << kTFOperShift;
-      fOper[code] += param;
-   }
-   inline Int_t     *GetOperOptimized() const { return fOperOptimized; }
-   inline Short_t    GetActionOptimized(Int_t code) const { return fOperOptimized[code] >> kTFOperShift; }
-   inline Int_t      GetActionParamOptimized(Int_t code) const { return fOperOptimized[code] & kTFOperMask; }
-
-   inline void       SetActionOptimized(Int_t code, Int_t value, Int_t param = 0) {
-      fOperOptimized[code]  = (value) << kTFOperShift;
-      fOperOptimized[code] += param;
-   }
-
-   void            ClearFormula(Option_t *option="");
-   virtual Bool_t  IsString(Int_t oper) const;
-
-   virtual void    Convert(UInt_t fromVersion);
-   //
-   // Functions  - used for formula evaluation
-   Double_t        EvalParFast(const Double_t *x, const Double_t *params);
-   Double_t        EvalPrimitive(const Double_t *x, const Double_t *params);
-   Double_t        EvalPrimitive0(const Double_t *x, const Double_t *params);
-   Double_t        EvalPrimitive1(const Double_t *x, const Double_t *params);
-   Double_t        EvalPrimitive2(const Double_t *x, const Double_t *params);
-   Double_t        EvalPrimitive3(const Double_t *x, const Double_t *params);
-   Double_t        EvalPrimitive4(const Double_t *x, const Double_t *params);
-
-   // Action code for Version 6 and above.
-   enum {
-      kEnd      = 0,
-      kAdd      = 1, kSubstract = 2,
-      kMultiply = 3, kDivide    = 4,
-      kModulo   = 5,
-
-      kcos      = 10, ksin  = 11 , ktan  = 12,
-      kacos     = 13, kasin = 14 , katan = 15,
-      katan2    = 16,
-      kfmod     = 17,
-
-      kpow      = 20, ksq = 21, ksqrt     = 22,
-
-      kstrstr   = 23,
-
-      kmin      = 24, kmax = 25,
-
-      klog      = 30, kexp = 31, klog10 = 32,
-
-      kpi     = 40,
-
-      kabs    = 41 , ksign= 42,
-      kint    = 43 ,
-      kSignInv= 44 ,
-      krndm   = 50 ,
-
-      kAnd      = 60, kOr          = 61,
-      kEqual    = 62, kNotEqual    = 63,
-      kLess     = 64, kGreater     = 65,
-      kLessThan = 66, kGreaterThan = 67,
-      kNot      = 68,
-
-      kcosh   = 70 , ksinh  = 71, ktanh  = 72,
-      kacosh  = 73 , kasinh = 74, katanh = 75,
-
-      kStringEqual = 76, kStringNotEqual = 77,
-
-      kBitAnd    = 78, kBitOr     = 79,
-      kLeftShift = 80, kRightShift = 81,
-
-      kJumpIf = 82, kJump = 83,
-
-      kexpo   = 100 , kxexpo   = 100, kyexpo   = 101, kzexpo   = 102, kxyexpo   = 105,
-      kgaus   = 110 , kxgaus   = 110, kygaus   = 111, kzgaus   = 112, kxygaus   = 115,
-      klandau = 120 , kxlandau = 120, kylandau = 121, kzlandau = 122, kxylandau = 125,
-      kpol    = 130 , kxpol    = 130, kypol    = 131, kzpol    = 132,
-
-      kParameter       = 140,
-      kConstant        = 141,
-      kBoolOptimize    = 142,
-      kStringConst     = 143,
-      kVariable        = 144,
-      kFunctionCall    = 145,
-      kData            = 146,
-      kUnary           = 147,
-      kBinary          = 148,
-      kThree           = 149,
-      kDefinedVariable = 150,
-      kDefinedString   = 151,
-      //
-      kPlusD           = 152,
-      kPlusDD          = 153,
-      kMultD           = 154,
-      kMultDD          = 155,
-      kBoolOptimizeOr  = 156,
-      kBoolOptimizeAnd = 157,
-      kBoolSet         = 158,
-      kFDM             = 159,
-      kFD0             = 160,
-      kFD1             = 161,
-      kFD2             = 162,
-      kFD3             = 163
-   };
-
-public:
-   // TFormula status bits
-   enum {
-      kNotGlobal     = BIT(10),  // don't store in gROOT->GetListOfFunction
-      kNormalized    = BIT(14),   // set to true if the function (ex gausn) is normalized
-      kLinear        = BIT(16)    //set to true if the function is for linear fitting
-   };
-
-               TFormula();
-               TFormula(const char *name,const char *formula);
-               TFormula(const TFormula &formula);
-   TFormula&   operator=(const TFormula &rhs);
-      ~TFormula() override;
-
- public:
-   virtual void        Optimize();
-   virtual void        Analyze(const char *schain, Int_t &err, Int_t offset=0);
-   virtual Bool_t      AnalyzeFunction(TString &chaine, Int_t &err, Int_t offset=0);
-   virtual Int_t       Compile(const char *expression="");
-   void        Copy(TObject &formula) const override;
-   void        Clear(Option_t *option="") override;
-   virtual char       *DefinedString(Int_t code);
-   virtual Double_t    DefinedValue(Int_t code);
-   virtual Int_t       DefinedVariable(TString &variable,Int_t &action);
-   virtual Double_t    Eval(Double_t x, Double_t y=0, Double_t z=0, Double_t t=0) const;
-   virtual Double_t    EvalParOld(const Double_t *x, const Double_t *params=nullptr);
-   virtual Double_t    EvalPar(const Double_t *x, const Double_t *params=nullptr){return ((*this).*fOptimal)(x,params);};
-   virtual const TObject *GetLinearPart(Int_t i);
-   virtual Int_t       GetNdim() const {return fNdim;}
-   virtual Int_t       GetNpar() const {return fNpar;}
-   virtual Int_t       GetNumber() const {return fNumber;}
-   virtual TString     GetExpFormula(Option_t *option = "") const;
-   Double_t            GetParameter(Int_t ipar) const;
-   Double_t            GetParameter(const char *name) const;
-   virtual Double_t   *GetParameters() const {return fParams;}
-   virtual void        GetParameters(Double_t *params){for(Int_t i=0;i<fNpar;i++) params[i] = fParams[i];}
-   virtual const char *GetParName(Int_t ipar) const;
-   virtual Int_t       GetParNumber(const char *name) const;
-   virtual Bool_t      IsLinear() const {return TestBit(kLinear);}
-   virtual Bool_t      IsNormalized() const {return TestBit(kNormalized);}
-   void        Print(Option_t *option="") const override; // *MENU*
-   virtual void        ProcessLinear(TString &replaceformula);
-   virtual void        SetNumber(Int_t number) {fNumber = number;}
-   virtual void        SetParameter(const char *name, Double_t parvalue);
-   virtual void        SetParameter(Int_t ipar, Double_t parvalue);
-   virtual void        SetParameters(const Double_t *params);
-   virtual void        SetParameters(Double_t p0,Double_t p1,Double_t p2=0,Double_t p3=0,Double_t p4=0,
-                                     Double_t p5=0,Double_t p6=0,Double_t p7=0,Double_t p8=0,
-                                     Double_t p9=0,Double_t p10=0); // *MENU*
-   virtual void        SetParName(Int_t ipar, const char *name);
-   virtual void        SetParNames(const char *name0="p0",const char *name1="p1",const char
-                                   *name2="p2",const char *name3="p3",const char
-                                   *name4="p4", const char *name5="p5",const char *name6="p6",const char *name7="p7",const char
-                                   *name8="p8",const char *name9="p9",const char *name10="p10"); // *MENU*
-   virtual void        Update() {}
-
-   static  void        SetMaxima(Int_t maxop=1000, Int_t maxpar=1000, Int_t maxconst=1000);
-   static  void        GetMaxima(Int_t& maxop, Int_t& maxpar, Int_t& maxconst);
-
-   void Streamer(TBuffer &b, const TClass *onfile_class);
-   void Streamer(TBuffer &b, Int_t version, UInt_t start, UInt_t count, const TClass *onfile_class = nullptr);
-
-   ClassDefOverride(ROOT::v5::TFormula,8)  //The formula base class  f(x,y,z,par)
-};
-
-   } // end namespace v5
-
-} // end namespace ROOT
+#ifndef G__DICTIONARY
+#warning "v5 legacy header has been moved to ROOT subfolder. This header is deprecated and will be removed in ROOT 6.44. Use 'ROOT/v5/TFormula.h'."
+#endif
 
 #endif
diff --git a/hist/hist/inc/v5/TFormulaPrimitive.h b/hist/hist/inc/v5/TFormulaPrimitive.h
index 78602169129cc..07f75fcc13e33 100644
--- a/hist/hist/inc/v5/TFormulaPrimitive.h
+++ b/hist/hist/inc/v5/TFormulaPrimitive.h
@@ -1,101 +1,10 @@
-// @(#)root/hist:$Id$
-// Author: Marian Ivanov, 2005
+#ifndef ROOT_v5_TFormulaPrimitive_fwd
+#define ROOT_v5_TFormulaPrimitive_fwd
 
-/*************************************************************************
-* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
-* All rights reserved.                                                  *
-*                                                                       *
-* For the licensing terms see $ROOTSYS/LICENSE.                         *
-* For the list of contributors see $ROOTSYS/README/CREDITS.             *
-*************************************************************************/
-// ---------------------------------- TFormulaPrimitive.h
-
-#ifndef ROOT_v5_TFormulaPrimitive
-#define ROOT_v5_TFormulaPrimitive
-
-
-
-//////////////////////////////////////////////////////////////////////////
-//                                                                      //
-// TFormulaPrimitive                                                    //
-//                                                                      //
-// The formula primitive base class                                     //
-//                                                                      //
-//////////////////////////////////////////////////////////////////////////
-
-#include "TNamed.h"
-#include "TBits.h"
-
-class TObjArray;
-
-namespace ROOT {
-
-   namespace v5 {
-
-class TFormula;
-
-class TFormulaPrimitive : public TNamed
-{
-   friend class ROOT::v5::TFormula;
-public:
-   typedef Double_t (*GenFuncG)(const Double_t*,const Double_t*);
-   typedef Double_t (*GenFunc0)();
-   typedef Double_t (*GenFunc10)(Double_t);
-   typedef Double_t (*GenFunc110)(Double_t,Double_t);
-   typedef Double_t (*GenFunc1110)(Double_t,Double_t, Double_t);
-   typedef Double_t (TObject::*TFuncG)(const Double_t*,const Double_t*) const;
-   typedef Double_t (TObject::*TFunc0)() const;
-   typedef Double_t (TObject::*TFunc10)(Double_t) const;
-   typedef Double_t (TObject::*TFunc110)(Double_t,Double_t) const;
-   typedef Double_t (TObject::*TFunc1110)(Double_t,Double_t,Double_t) const;
-protected:
-   static TObjArray * fgListOfFunction;                   ///<!list of global primitive formulas
-   static Int_t       BuildBasicFormulas();               //build list of basic formulas
-   union {
-      GenFuncG    fFuncG;                                 ///<!pointer to the TFormula generic function
-      GenFunc0    fFunc0;                                 ///<!pointer to the function
-      GenFunc10   fFunc10;                                ///<!pointer to the function
-      GenFunc110  fFunc110;                               ///<!pointer to the function
-      GenFunc1110 fFunc1110;                              ///<!pointer to the function
-      TFuncG      fTFuncG;                                ///<!pointer to the TFormula generic function
-      TFunc0      fTFunc0;                                ///<! pointer to member function
-      TFunc10     fTFunc10;                               ///<! pointer to member function
-      TFunc110    fTFunc110;                              ///<! pointer to member function
-      TFunc1110   fTFunc1110;                             ///<! pointer to member function
-   };
-   Int_t      fType;                                      //type of the function
-   Int_t      fNArguments;                                //number of arguments
-   Int_t      fNParameters;                               //number of parameters
-   Bool_t     fIsStatic;                                  // indication if the function is static
-private:
-   TFormulaPrimitive(const TFormulaPrimitive&) = delete;
-   TFormulaPrimitive& operator=(const TFormulaPrimitive&) = delete;
-public:
-   TFormulaPrimitive();
-   TFormulaPrimitive(const char *name,const char *formula, GenFunc0 fpointer);
-   TFormulaPrimitive(const char *name,const char *formula, GenFunc10 fpointer);
-   TFormulaPrimitive(const char *name,const char *formula, GenFunc110 fpointer);
-   TFormulaPrimitive(const char *name,const char *formula, GenFunc1110 fpointer);
-   TFormulaPrimitive(const char *name,const char *formula, GenFuncG fpointer,Int_t npar);
-   TFormulaPrimitive(const char *name,const char *formula, TFunc0 fpointer);
-   TFormulaPrimitive(const char *name,const char *formula, TFunc10 fpointer);
-   TFormulaPrimitive(const char *name,const char *formula, TFunc110 fpointer);
-   TFormulaPrimitive(const char *name,const char *formula, TFunc1110 fpointer);
-   TFormulaPrimitive(const char *name,const char *formula, TFuncG fpointer);
-   static Int_t AddFormula(TFormulaPrimitive * formula);
-   static TFormulaPrimitive* FindFormula(const char* name);
-   static TFormulaPrimitive* FindFormula(const char* name, const char *args);
-   static TFormulaPrimitive* FindFormula(const char* name, UInt_t nargs);
-   Double_t Eval(Double_t* x);                   //eval primitive function
-   Double_t Eval(TObject *o,  Double_t *x);      //eval member function
-   Double_t Eval(Double_t *x, Double_t *param);  //eval primitive parametric function
-
-   ClassDefOverride(ROOT::v5::TFormulaPrimitive,0)  //The primitive formula
-};
-
-   } // end namespace v5
-
-} // end namespace ROOT
+#include "ROOT/v5/TFormulaPrimitive.h"
 
+#ifndef G__DICTIONARY
+#warning "v5 legacy header has been moved to ROOT subfolder. This header is deprecated and will be removed in ROOT 6.44. Use 'ROOT/v5/TFormulaPrimitive.h'."
+#endif
 
 #endif
diff --git a/hist/hist/src/TF1.cxx b/hist/hist/src/TF1.cxx
index 8ca357fde9959..7aee5342face6 100644
--- a/hist/hist/src/TF1.cxx
+++ b/hist/hist/src/TF1.cxx
@@ -50,7 +50,7 @@
 #include "Math/ChebyshevPol.h"
 #include "Fit/FitResult.h"
 // for I/O backward compatibility
-#include "v5/TF1Data.h"
+#include "ROOT/v5/TF1Data.h"
 
 #include "AnalyticalIntegrals.h"
 
diff --git a/hist/hist/src/TF1Data_v5.cxx b/hist/hist/src/TF1Data_v5.cxx
index bed79aab4254a..c58983e854625 100644
--- a/hist/hist/src/TF1Data_v5.cxx
+++ b/hist/hist/src/TF1Data_v5.cxx
@@ -9,7 +9,7 @@
  * For the list of contributors see $ROOTSYS/README/CREDITS.             *
  *************************************************************************/
 
-#include "v5/TF1Data.h"
+#include "ROOT/v5/TF1Data.h"
 
 #include "TBuffer.h"
 #include "TH1.h"
diff --git a/hist/hist/src/TFormula.cxx b/hist/hist/src/TFormula.cxx
index 2888bf66c7c75..53d0c49f79b6c 100644
--- a/hist/hist/src/TFormula.cxx
+++ b/hist/hist/src/TFormula.cxx
@@ -37,7 +37,7 @@ using std::map, std::pair, std::make_pair, std::list, std::max, std::string;
 #ifdef WIN32
 #pragma optimize("",off)
 #endif
-#include "v5/TFormula.h"
+#include "ROOT/v5/TFormula.h"
 
 
 namespace {
diff --git a/hist/hist/src/TFormulaMathInterface.cxx b/hist/hist/src/TFormulaMathInterface.cxx
index c8ae5aa2558e1..3b0e7ae125932 100644
--- a/hist/hist/src/TFormulaMathInterface.cxx
+++ b/hist/hist/src/TFormulaMathInterface.cxx
@@ -1,4 +1,4 @@
-#include "v5/TFormulaPrimitive.h"
+#include "ROOT/v5/TFormulaPrimitive.h"
 #include "TMath.h"
 
 namespace ROOT {
diff --git a/hist/hist/src/TFormulaPrimitive_v5.cxx b/hist/hist/src/TFormulaPrimitive_v5.cxx
index 92b501ded3ade..4e691c13c0682 100644
--- a/hist/hist/src/TFormulaPrimitive_v5.cxx
+++ b/hist/hist/src/TFormulaPrimitive_v5.cxx
@@ -9,7 +9,7 @@
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
 
-#include "v5/TFormulaPrimitive.h"
+#include "ROOT/v5/TFormulaPrimitive.h"
 
 #include "TMath.h"
 #include "TNamed.h"
diff --git a/hist/hist/src/TFormula_v5.cxx b/hist/hist/src/TFormula_v5.cxx
index 172b4ec207722..1bc2f0ee49e3c 100644
--- a/hist/hist/src/TFormula_v5.cxx
+++ b/hist/hist/src/TFormula_v5.cxx
@@ -12,14 +12,14 @@
 #include "TROOT.h"
 #include "TClass.h"
 #include "TBuffer.h"
-#include "v5/TFormula.h"
+#include "ROOT/v5/TFormula.h"
 #include "TMath.h"
 #include "TRandom.h"
 #include "TFunction.h"
 #include "TMethodCall.h"
 #include "TObjString.h"
 #include "TError.h"
-#include "v5/TFormulaPrimitive.h"
+#include "ROOT/v5/TFormulaPrimitive.h"
 #include "TInterpreter.h"
 #include "TVirtualMutex.h"
 #include "strlcpy.h"
@@ -40,7 +40,7 @@ namespace ROOT {
 
    namespace v5 {
 
-/** \class TFormula  TFormula.h "inc/v5/TFormula.h"
+/** \class TFormula  TFormula.h "inc/ROOT/v5/TFormula.h"
      \ingroup Hist
 The FORMULA class (ROOT version 5)
 
diff --git a/test/TFormulaTests.cxx b/test/TFormulaTests.cxx
index 7df6e9da98ee4..46f87b67f5368 100644
--- a/test/TFormulaTests.cxx
+++ b/test/TFormulaTests.cxx
@@ -9,7 +9,7 @@
 #include <TSystem.h>
 #include <TApplication.h>
 #include <TFormula.h>
-#include <v5/TFormula.h>
+#include <ROOT/v5/TFormula.h>
 #include <TRandom.h>
 #include <iostream>
 #include "TFormulaParsingTests.h"
diff --git a/tree/treeplayer/inc/TTreeFormula.h b/tree/treeplayer/inc/TTreeFormula.h
index 67324d3b08ea2..83cf05052166a 100644
--- a/tree/treeplayer/inc/TTreeFormula.h
+++ b/tree/treeplayer/inc/TTreeFormula.h
@@ -23,7 +23,7 @@
 //                                                                      //
 //////////////////////////////////////////////////////////////////////////
 
-#include "v5/TFormula.h"
+#include "ROOT/v5/TFormula.h"
 
 #include "TLeaf.h"