The test should reuse the prebuilt modules in the module cache. However,
due to a mismatch between the module-related flags exported by FindROOT.
There is a mismatch between the -D passed by cmake.

This patch make sure that the build arguments match more closely the build
setup of ROOT. Thus we can reuse the already built module files.

This should unstick our modules builds.

Adding Math/Math.h to the MathCore module makes the generation of GenVector
dictionary hand due to a bug in rootcling/clang. The redeclaration chain of
'abs' shadow declaration (from stl math.h) is broken.

In general there are a few remaining issues with stl's cmath, math.h and
libc math.h header files. We cannot yet reliably put them in the modulemaps.
This causes the current issue: we end up with content duplication which
triggers a bugs in clang.

These headers are modular, this makes pcm a little bit smaller.

...and viceversa. Only non-adopting RAdoptAllocators can be rebound.
This makes it possible to copy-construct RVec<bool>'s from other
RVec<bool>'s.

The different semantics of std::vector<bool> make memory adoption through a
custom allocator more complex -- namely, RAdoptAllocator<bool> must be
rebindable to RAdoptAllocator<unsigned long>, but if adopted memory is
really a buffer of bools, reinterpretation of the adopted buffer as a
different type is going to break things in horrible ways.
As a workaround, RAdoptAllocator<bool> is specialized to be a simple
allocator that forwards calls to std::allocator, never adopts memory, and
can be rebound to any other allocator (as it never adopts memory it can
rebind the same way that std::allocator can).

This should resolve ROOT-9453 "Cannot instantiate RVec<bool>".

[layering] Updating linkdef files for Core and MathCore, after moving sorting and binary search algorithms from MathCore to Core

[layering] Moving BinarySearch and Sorting algorithms from math/mathcore/inc/TMath.h to TMathBase.h (evolution to ROOT "<algorithm>" header)

Add possibility to extend XML buffer size. Set also output precision of matrix in xml dependent on the type

[Modulariz] Cleaning out Mathcore from Hist includes and changing relative paths for LinkDef files to allow a build from outside of build system of ROOT

Flag in NegativeG2LineSearch if the cov matrix is not pos-defined. In this case when in VariableMetric we exit the function minimum is set to be invalid.
This should fix ROOT-9522

clad is a C++ plugin for clang and cling that implements automatic
differentiation of user-defined functions by employing the chain rule in
forward and reverse mode, coupled with source code transformation and AST
constant fold.

In mathematics and computer algebra, automatic differentiation (AD) is a
set of techniques to numerically evaluate the derivative of a function
specified by a computer program. AD exploits the fact that every computer
program, no matter how complicated, executes a sequence of elementary
arithmetic operations (addition, subtraction, multiplication, division, etc.)
and elementary functions (exp, log, sin, cos, etc.). By applying the chain
rule repeatedly to these operations, derivatives of arbitrary order can
be computed automatically, accurately to working precision, and using at
most a small constant factor more arithmetic operations than the original
program.

AD is an alternative technique to symbolic and numerical differentiation.
These classical methods run into problems: symbolic differentiation leads
to inefficient code (unless done carefully) and faces the difficulty of
converting a computer program into a single expression, while numerical
differentiation can introduce round-off errors in the discretization
process and cancellation. Both classical methods have problems with
calculating higher derivatives, where the complexity and errors increase.
Finally, both classical methods are slow at computing the partial
derivatives of a function with respect to many inputs, as is needed for
gradient-based optimization algorithms. Automatic differentiation solves
all of these problems, at the expense of introducing more software
dependencies.

This patch allows ROOT to interoperate with clad. Namely, users can ask
the interpreter to produce a derivative or a gradient to a known function.

An illustrative example code for first order derivative:

root [0] #include "Math/CladDerivator.h"
root [1] double my_pow2(double x) { return x*x; }
root [2] auto meta_obj = clad::differentiate(my_pow2, /*wrt 1-st argument*/0);
root [3] meta_obj.dump();
The code is: double my_pow2_darg0(double x) {
    return (1. * x + x * 1.);
}
root [5] meta_obj.execute(1) // no iterations, at the cost of function call.
(double) 2.0000000

Learn more about clad at https://github.com/vgvassilev/clad

Patch by Aleksandr Efremov and me!

When using builtin_openssl=ON, CMake erroneously exports the builtin
static libraries in ROOTConfig-targets.cmake, which causes problems with
dependent projects. In order to avoid this, we need Net and RHTTP to use
SSL as a private dependency. Since CMake requires target_link_libraries()
to either be all-plain (as before) or all-keyword (required to allow
PRIVATE linking), we need to move the build system to use all-keyword
linking only.

Fixes: ROOT-9532

Remove non thread safe additions when parallelizing the fit