by reducing the number of events by a factor 100 for:
- ProgressHelper_Existence_ST
- ProgressHelper_Existence_MT
- ProgressHelper_existence_singleTTreeInput

and by removing jitting in favor of compilation where possible.
The coverage is the same as before.

by about two orders of magnitude (150 s --> 1s) by using a
reasonable number of threads throughout the battery of tests
(in some cases the machine could be heavily overcommitted) and
by eliminating the RDF jitting, which happens sequentially.

by a factor ~2x (100s -> 50s)by eliminating jitting in favor of
fully compiled RDF instances where possible, i.e. w/o reducing
test coverage.

This commit reorganizes the RLoopManager::Run function, encapsulating
the cleanup of the RDF nodes in the destructor of a class in order to
profit from RAII and perform all necessary operations even if the event
loop is interrupted by an exception.

Add a unit test for the cleanup happening after the event loop is
interrupted by an exception.
Moreover, adapt two existing unit tests to the new implementation of
RLoopManager::Run. The two tests relied on a faulty behaviour of RDF,
which allowed to trigger subsequent event loops by dereferencing
RResultPtr's instances and trapping the exception thrown during the
event loop in a try-catch block.

As requested in this forum post:
https://root-forum.cern.ch/t/memory-leak-in-fits/56249/4

The number of thread blocks in kernel calls should not be excessively
large, it's sufficient if it's in the order of the number of streaming
multiprocessors.

In particular, this circumvents a problem with the NLL reduction kernels
with grid sizes larger than 512.

With this change, there are potentially less threads than events when
summing likelihoods, so in the NLL reduction kernels, each thread also
has to reduce a few elements in a loop.

Closes root-project#13603.

There are different overloads of `RooFit::Import()` for importing
different object types to RooFit dataset classes.

However, they return a `RooCmdArg` that is named after the type of the
imported object. That causes some inconsistencies. For example, if you
import a map of `std::unique_ptr<RooDataHist>`, the name will be
different than for `RooDataHist*` because there is a special overload
for the latter.

It is better to fixup this inconsistency, and then disentangle the
different types in the functions that consume these `RooFit::Import()`
command arguments.

This caused some trouble when importing RooDataHists into a combined
dataset, which is why this fix is coming now.

These changes are covered by the tutorial tests.

This is to enable support for expressions representing the complicated
amplitudes in partial wave analysis.

This should preserve backwards compatibility, because `const char*`
implicitly casts to `std::string`.

If you call `makePdfInstance` or `makeFunctionInstance` twice in a row
with the same arguments, the RooClassFactory should not have to
recompile anything.

This is particularly important to support the jupyter notebook workflow,
where the same cell might be run several times.

In fact, before this commit, calling the `makeClassInstance` function
twice in a row with the same arguments resulted in a crash.

because they accidentally dropped out from the building and testing
process during the migration to CMake.
Minimal changes to the code were applied to let them run,
respecting the original coding style.

If there are no requests are processed during last 500 attempts,
timer switch to the slow mode with 100 ms period.
But immediately switched back to fast mode if new if new requests are
processed.

This is very special mode will be used only for the python,
which creates special thread for events processing.
And this thread is changing with the time

It is intermediate state when web window is shown,
but no active connection is established.
At such moment canvas->Update() was not updating objects - like
invoking THStack::BuildPrimitives() to introduce all necessary
histograms. Therefore create artificial batch connection which
do exactly same job as active web window connection - but does not
send any data.

Also improve timer handling in TWebCanvas. Instead of
enabling/disabling this timer just use fast or slow mode - changing
intervals

Instead

Internally web window has special checks for thread id - when it
assigned. With external events processing such thread is not set

In such special mode web canvas or any other web components created
from the main python thread - which stored at the moment when
web win manager created. Callback only from this thread are allowed -
all other threads has to be ignored.

This function called regularly from interactive python session
and can be used for proper update of the active canvas

Now first connection in list is batch connection,
used for async update.

Also, throw an exception with a helpful error message if the user
attempts to use `RooFit::Slice()` with a comma-separates list of
category states, which is not supported.

This addresses a question on the forum:
https://root-forum.cern.ch/t/plotting-two-categories-of-simultaneous-fit-in-a-single-plot/56250

Fix axis labels tilt
Fix THStack update
Support e1hist combination of draw options
th1 render order of filled area and markers

As seen in pytorch/pytorch#82628. This removes the
`TypeError: 'torch._C.Node' object is not subscriptable` error.

We do not show this anymore, and this requires complex operations and
- in its current implementation - a working ROOT build as part of the
version update.

This simplifies the release procedure: no more bootstrapping, no more
running of scripts; the source is the source.

Given that the source now has the authoritative version number for
releases (unlike for dev branches, of course) the ROOT package version
is now determined from that header, rather than git describe which is
less reliable.

The updated release procedure will appear at https://root.cern/for_developers/release_checklist/

build/version_number is gone.

The `n_in_range` reference value in the unit test
`roodataset_numpy.TestRooDataSetNumpy.test_ignoring_out_of_range`
apparently doesn't get computed right on some 32 platforms.

I can't reproduce the problem, but I'm sure it will be fixed by avoiding
the use of the operators `&` and `|` with numpy arrays. Just doing a
manual loop in Python should be more platform independent.

Closes root-project#12162.

which is `root/net/net/src/TNetFile.cxx:19:29: warning: '/*' within
block comment [-Wcomment]` on clang on macos 13.5.1

The "Math/Error.h" header is not shipped with standalone Minuit2.

It is not a perfect solution to just ship it with Minuit2, because the
Error.h header behaves differently depending on the
`MATHCORE_STANDALONE` macro being defined or not. The code would only
work correctly if the user defines the `MATHCORE_STANDALONE` herself in
the user code that uses standalone Minuit2, which would be annoying.

Instead, this commit proposes another solution to the problem: for all
headers also used in Minuit2 standalone, MathCore
moves the definitions of all functions that use `Math/Error.h` out of
the header files in the cxx files. Like this, the `Math/Error.h` is only
a build dependency of standalone Minuit2, and the user doesn't need to
define the `MATHCORE_STANDALONE` macro for it to work.

Including the "Math/Util.h" header needs to be avoided for similar
reasons (it's about another preprocessor macro related to `veccore`).

Go back to use .h5 files instead of .keras due to a problem in Keras loading .keras files on MacOS ARM (see https://github.com/keras-team/keras/issues/18278 )

Disbaling it causes an interference with multiprocessing and a restart of the process after it is endeded. This fixes the timeout of the PyKeras tests on MacOS.

This commits apply also some small fixes/improvements  on the deletetion of some TMVA objects.

…tom operators

To add the custom operator the function Load is added in RSofieReader

Fix also the Keras parsing tests to use RSofieReader

Add also a function to print the output tensors in RModel

Reduce number of events to avoid timeout of the test. Do this separtly for MAcOSX, since we cannot disable there eager execution

There was an evil hack in `RooAbsOptTestStatistic`:

```c++
_dataClone->cacheArgs(this,_cachedNodes,_normSet,!_funcClone->getAttribute("BinnedLikelihood")) ;
```

The final parameter determins if zero weights should be skipped when
recalculating the caches. Indeed, for the NLL case, this corresponds to
the BinnedLikelihood attrribute being present or not, but it broke the
other test statistics for which zero weights should not be skipped at
all.

This commit suggests a safer way to manage this with a new
`RooAbOptTestStatistic::_skipZeroWeights` flag.

In particular, this change fixed a bug that got uncovered during a forum
discussion:

https://root-forum.cern.ch/t/failing-chi2-fit/56309/3

It is confusing to the users that the chi2 fit is by default not
extended, even if the pdf is extended. Because this is what happens in
normal likelihood fits.

This commit makes that behavior consistent and explains it in the
release notes.

Also, a new error message is added for the case you forcing a non
extended fit on a pdf that must be extended, because this is guaranteed
to give wrong results.

The test statistic classes should not be used directly, but always via
the `createNLL()` (or in this case `createChi2()`) wrapper.

This commit improves the documentation of `RooAbsPdf::fitTo()` and
`RooAbsReal::chi2FitTo()` by adding a more detailed explanation of the
`Extended()` command argument.

Also, renamed "bounds" to "edges" for data export.

This is useful for debugging, but off by default.

The fit results of Minuit2 are less random, and therefore we can tighten
the test tolerance.

Fitting empty datasets doesn't give you a well-defined likelihood, and
Minuit2 would actually explicitly print errors that would cause the test
to fail.

It's better to actually simulate non-empty toy datasets for fitting.
Then, the unit tests will also pass when Minuit2 will be the default in
the future.

This is a potential problem:

```c++
   setMinimizerType(type);
   _theFitter->Config().SetMinimizer(type, alg);
```

The call to `setMinimizerType()` will set a default
minimizer if `type` is empty. This default minimizer is right now the
same as in general ROOT, but if RooFit would have a different default,
the default minimizer of the RooMinimizer and the internal `_theFitter`
would become out of sync, as `SetMinimizer(type)` takes the ROOT
default if type is empty, not the RooMinimizer default.

The better approach is this:

```c++
   setMinimizerType(type);
   _theFitter->Config().SetMinimizer(_cfg.minimizerType.c_str(), alg);
```

First, `setMinimizerType(type)` sets the minimizer type in
`_cfg.minimizerType`, and then this information is taken to set the
minimizer of the `ROOT::Fitter`.

By storing the reference normalization set also in an attribute, one
gets the JSON IO for the `_refCoefNorm` for free, because attributes are
always covered by the JSON IO.

In particular, this is used for the RooFit HS3 import and export.

As these classes are changed quite a bit by the previous and next
commits, it is a good time to format them now.

Add a flag to define the RooLognormal with `mu` and `sigma` instead of
their exponentiated values.

In particular, this is used for the RooFit HS3 import and export.

Almost a year ago, I fixed the support for comma-separated normalization
ranges for pdfs, e.g. `pdf.setNormRange("range1,range2")` was fixed also
for RooAddPdfs.

As a result, the logic for multi-range likelihood fits was removed from
`createNLL()`, because the multi-range fit didn't have to be treated as
a special case anymore.

The same applies also to chi-square fits. In fact, the reason why the
`RooChi2Var` constructor and `RooAbsReal::createChi2()` methods had a
`RooAbsPdf` overload was *only* this workaround! For regular
RooAbsReals, the workaround was not necessary, because there is no
normalization.

Therefore, quite a few functions were removed in this commit.

The multi-range chi2 fit is now also validated by the multi-range fit
unit test in `testRooAbsPdf`.

This is a follow-up to PR root-project#11455 (commit fa10523 in particular),
where the same change was already make for regular likelihoods.

It can be checked at runtime if a given `RooAbsReal` is a pdf or not.
Like this, we also don't need a separate override of
`createChi2(RooDataSet &)` in RooAbsPdf.

This is achieved in the same was as in `createNLL()`, by forwarding the
configuration options to the `RooAbsOptTestStatistic` base class.

After adding support for subrange fits with the `RooXYChi2Var`, it
initially didn't work because the y-value errors were missing in the
dataset. This is because `RooDataSet::reduce()` is not copying the
errors over to the reduced dataset, which is a bug.

Fortunately, there is a straighforward solution. To create the reduced
`RooDataSet`, it now doesn't use some buggy private constructor (that is
now removed), but instead the trusty `RooAbsData::emptyClone()` method,
for which I fixed the problem with the errors not being copied already
some time ago.

This should fix some of the failures observed for builds without rdataframe

It inform that Update() or UpdateAsync() methods were called.
Will be used in iPython to implement graphics update functionality

Keep list of display handles for TCanvas and if Update called -
try to update it. Works for jsroot and png display

Fix problem with IsShown() - also should be set in batch mode
Provide GetUID() method, which will be used in iPython

Handle same as for TCanvas.
Use RCanvas::GetUID() for canvas identifier.

This class provides all necessary functionality for web-based
display, including handling of stacks, stats, styles, colors and so on

Adjust layout of the div element - use 'relative' position to preserve
dimension of the JSROOT drawings.

Use GetWindowWidth()/GetWindowHeight() methods to get configured drawing
dimension, do not swap width/height parameters

When producing pdf document, set page size to maximal canvas size.
Also include margins into page size to let normally embed complete
canvas per page.

Preliminary 7.5.0 release for ROOT 6.30
Improve build legend functionality, provide as context menu command
Fix toggling of hist draw options

Add support of grayscale flag in the canvas

Instead direct call of Paint() call UpdateAsync()
Prevent Paint() when calling TCanvas::SetGrayscale

Nicer to distribute a BSD licensed version.
The file `COPYING-CMAKE-SCRIPTS` is missing virtually worldwide,
not even CMake includes it: https://gitlab.kitware.com/search?search=COPYING-CMAKE-SCRIPTS&nav_source=navbar&project_id=541&group_id=415&search_code=true&repository_ref=master

In preparation for a future removal of Python 2 support, add the
`pyroot-python2` cmake build option (OFF by default). Users who really need
Python 2 support can still get it, but warn them that it will be removed in a
future ROOT release.

Fully implement the `Offset("bin")` feature also for RooDataSet, both
with CPU/CUDA BatchMode and the legacy tests statistics.

This is done now by introducing a new element in the computation graph:
an "offset pdf" that is created as a RooHistPdf from the observed data,
and it is used to get the counterterm in each bin.

It was validated with the `rf614` tutorial that this binwise offsetting
is indeed fixing the convergense problems that the simple offsetting by
the initial NLL value can't fix.

Closes root-project#11965.

There was a little bug in `fitTo()` when the new modular test statistics
got implemented in fe6935b. If the `ModularL` command is not passed,
the offsetting flag should be forwarded to `createNLL()`, because only
for the new test statistics the offsetting is done in the minimizer
only.

The  RooFitCommon library only contained one single function to create a
temporary directory `/tmp/roofit/` that was not even platform
independed.

This commit suggests to use `gSystem->TempDirectory()` instead, and
prefix the temporary files with `roofit_` so there is no need for
creating another subdirectory.

We can avoid the const-term-optimization in BatchMode or `codegen`
simply by overriding the relevant function in the wrapper classes.

The function that steered the chi2 minimization had almost the exact
same implementation as the one steering the likelihood fits. It would be
better is the chi2 fits also use the same function as the likelihood
fits, which is implemented in this PR.

This was done with the help of this very useful tool:
https://github.com/crate-ci/typos

This config parameter was already present for `stressRooStats`, and this
commit also adds it for `stressRooFit` and `stressHistFactory`.

The default minimizer is hardcoded to `Minuit`, not `Minuit2`.

Furthermore, the code is modernized a bit, for example by using raw
string literals and `int` instead of `Int_t`.

This is to make the test also pass when using Minuit2, where the post fit
parameters differ by a tiny bit, pushing one of the precision parameters
over the edge by 3 percent.

To have a bit of a margin, the relevant precision constants are
increased by 10 percent.

The contour implementation in Minuit2 doesn't work for these RooFit
tutorials yet.

For the estimated error on the upper limit, we need to loosen the
tolerance because it is determined on-the-fly with a fit, and not read
as a data member like the comment in the test said before.

Withg the default minimizer changing from Minuit to Minuit2, the results
are slightly different and caused this test to fail.

Most people prefer Minuit2 nowadays, especially RooFit users, as some of
the more complicated fits don't converge with the old Minuit
implementation.

In case ROOT was built without Minuit2 enabled, the default falls back
to `Minuit`.

Also, since there is a "default default" already hardcoded in
`MinimizerOptions.cxx`, it is not necessary to specify another "default
default" in the default `.rootrc`. The corresponding line is commented
out.