Skip to content

[hist] Remove CINT compatibility constructors from TF1, THF2, and TF3 #20702

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
guitargeek wants to merge 1 commit into
base: master
Choose a base branch
from
+1 −50
Open

[hist] Remove CINT compatibility constructors from TF1, THF2, and TF3 #20702

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions README/ReleaseNotes/v640/index.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -38,6 +38,7 @@ The following people have contributed to this new version:
* Comparing C++ `nullptr` objects with `None` in Python now raises a `TypeError`, as announced in the ROOT 6.38 release notes. Use truth-value checks like `if not x` or `x is None` instead.
* The `TGLIncludes.h` and `TGLWSIncludes.h` that were deprecated in ROOT 6.38 and scheduled for removal are gone now. Please include your required headers like `<GL/gl.h>` or `<GL/glu.h>` directly.
* The GLEW headers (`GL/eglew.h`, `GL/glew.h`, `GL/glxew.h`, and `GL/wglew.h`) that were installed when building ROOT with `builtin_glew=ON` are no longer installed. This is done because ROOT is moving away from GLEW for loading OpenGL extensions.
* The `TF1`, `TF2`, and `TF3` constructors for CINT compatibility were removed. This concerns the templated constructors that additionally took the name of the used functor class and member function. With ROOT 6, these names can be omitted.

## Build System

Expand Down
15 changes: 0 additions & 15 deletions hist/hist/inc/TF1.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -352,15 +352,6 @@ class TF1 : public TNamed, public TAttLine, public TAttFill, public TAttMarker {
ROOT::Internal::TF1Builder<Func>::Build(this, f);
}

// backward compatible interface
template <typename Func>
TF1(const char *name, Func f, Double_t xmin, Double_t xmax, Int_t npar, const char *, EAddToList addToGlobList = EAddToList::kDefault) :
Copy link
Member

@pcanal pcanal Dec 11, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Should we deprecate them first or are we sure they were only use by/via CINT?

Copy link
Contributor Author

@guitargeek guitargeek Dec 12, 2025 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I don't see why anyone would use these constructors otherwise, as it's not needed in C++ to pass the name of the class instance Func as a separate argument.

The reason why I think we can remove it without deprecation is that the replacement is trivial and backwards compatible: just drop these const char* inputs at the end. But if you're more comfortable with a deprecation period, I have no problem.

Maybe @lmoneta also has a opinion there?

TF1(EFType::kTemplScalar, name, xmin, xmax, npar, 1, addToGlobList, new TF1Parameters(npar))
{
ROOT::Internal::TF1Builder<Func>::Build(this, f);
}


// Template constructors from a pointer to any C++ class of type PtrObj with a specific member function of type
// MemFn.
// The member function must have the signature of (double * , double *) and returning a double.
Expand All @@ -374,12 +365,6 @@ class TF1 : public TNamed, public TAttLine, public TAttFill, public TAttMarker {
TF1(EFType::kTemplScalar, name, xmin, xmax, npar, ndim, addToGlobList, new TF1Parameters(npar), new TF1FunctorPointerImpl<double>(ROOT::Math::ParamFunctor(p, memFn)))
{}

// backward compatible interface
template <class PtrObj, typename MemFn>
TF1(const char *name, const PtrObj &p, MemFn memFn, Double_t xmin, Double_t xmax, Int_t npar, const char *, const char *, EAddToList addToGlobList = EAddToList::kDefault) :
TF1(EFType::kTemplScalar, name, xmin, xmax, npar, 1, addToGlobList, new TF1Parameters(npar), new TF1FunctorPointerImpl<double>(ROOT::Math::ParamFunctor(p, memFn)))
{}

TF1(const TF1 &f1);
TF1 &operator=(const TF1 &rhs);
~TF1() override;
Expand Down
19 changes: 0 additions & 19 deletions hist/hist/inc/TF2.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -53,15 +53,6 @@ class TF2 : public TF1 {
fNpx = 30;
}

/// Backward compatible ctor
template <class PtrObj, typename MemFn>
TF2(const char *name, const PtrObj& p, MemFn memFn, Double_t xmin, Double_t xmax, Double_t ymin, Double_t ymax, Int_t npar, const char * , const char *) :
TF1(name,p,memFn,xmin,xmax,npar,2),
fYmin(ymin), fYmax(ymax), fNpy(30), fContour(0)
{
fNpx = 30;
}

/// Template constructors from any C++ callable object, defining the operator() (double * , double *) and returning a double.
template <typename Func>
TF2(const char *name, Func f, Double_t xmin, Double_t xmax, Double_t ymin, Double_t ymax, Int_t npar,Int_t ndim = 2, EAddToList addToGlobList = EAddToList::kDefault) :
Expand All @@ -71,16 +62,6 @@ class TF2 : public TF1 {
fNpx = 30;
}

/// Backward compatible ctor
template <typename Func>
TF2(const char *name, Func f, Double_t xmin, Double_t xmax, Double_t ymin, Double_t ymax, Int_t npar,const char *) :
TF1(name,f,xmin,xmax,npar,2),
fYmin(ymin), fYmax(ymax), fNpy(30), fContour(0)
{
fNpx = 30;
}


TF2(const TF2 &f2);
TF2 &operator=(const TF2& rhs);
~TF2() override;
Expand Down
16 changes: 0 additions & 16 deletions hist/hist/inc/TF3.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -53,14 +53,6 @@ class TF3 : public TF2 {
fZmin(zmin), fZmax(zmax), fNpz(30)
{ }

/// Backward compatible ctor
template <class PtrObj, typename MemFn>
TF3(const char *name, const PtrObj& p, MemFn memFn, Double_t xmin, Double_t xmax, Double_t ymin, Double_t ymax, Double_t zmin, Double_t zmax, Int_t npar,
const char * , const char * ) :
TF2(name,p,memFn,xmin,xmax,ymin,ymax,npar,3),
fZmin(zmin), fZmax(zmax), fNpz(30)
{ }

/// Template constructors from any C++ callable object, defining the operator() (double * , double *) and returning a double.
template <typename Func>
TF3(const char *name, Func f, Double_t xmin, Double_t xmax, Double_t ymin, Double_t ymax, Double_t zmin, Double_t zmax, Int_t npar,
Expand All @@ -69,14 +61,6 @@ class TF3 : public TF2 {
fZmin(zmin), fZmax(zmax), fNpz(30)
{ }

/// Backward compatible ctor
template <typename Func>
TF3(const char *name, Func f, Double_t xmin, Double_t xmax, Double_t ymin, Double_t ymax, Double_t zmin, Double_t zmax, Int_t npar,
const char * ) :
TF2(name,f,xmin,xmax,ymin,ymax,npar,3),
fZmin(zmin), fZmax(zmax), fNpz(30)
{ }

TF3(const TF3 &f3);
TF3& operator=(const TF3 &rhs);
~TF3() override;
Expand Down
Loading