Add argument confidence_interval_root_find indicating root finding method

[dachengx]

When calculating CL, if confidence_interval_root_find is brentq, use scipy.optimize.brentq; if extremal, look for the left or right-most root.

The left- right- most root finding is performed in utils.extremal_root. This function accepts almost the same arguments as scipy.optimize.brentq.

[coveralls]

Pull Request Test Coverage Report for Build 22446669536

Details

• 40 of 45 (88.89%) changed or added relevant lines in 2 files are covered.
• No unchanged relevant lines lost coverage.
• Overall coverage increased (+0.2%) to 76.425%

---

Changes Missing Coverage	Covered Lines	Changed/Added Lines	%
alea/utils.py	26	31	83.87%

Totals
Change from base Build 20990013760:	0.2%
Covered Lines:	1757
Relevant Lines:	2299

---

💛 - Coveralls

[hammannr]

On a first quick look this looks very nice! Could you think of a quick unites to make sure it stays that nice? 😄

[dachengx]

Thanks @hammannr . I have added a simple test of the new method

[hammannr]

I didn't run it yet, but just had a look at the code. Looks mostly good, and I will try running it asap. In the meantime, I left a few comments on things I noticed so far.

[hammannr]

Not really tests the method, but only if it fails to load it, no?

[dachengx]

Here it is tested

alea/tests/test_runner.py

Line 78 in f9c6942

if COMPUTE_CONFIDENCE_INTERVAL:

[hammannr]

sure but this doesnt' test if the function works properly, does it?

[hammannr]

Maybe we should assert that step is >=0, otherwise this will give unexpected behaviour or infinity loops.

[hammannr]

Same for step growth

[hammannr]

This option generally seems a bit unstable to me since it can explode or converge to zero, no?

[dachengx]

Yes, it might explode, so I set the default step_growth as 1.0, and the step does not increase.

[hammannr]

For convenience, also state here the two options, please.

[hammannr]

Please add a brief explanation for all the parameters of the function.

[hammannr]

I played with it a little bit and it' quite easy to find a case in which this produces RuntimeError: No root found in interval:
This works fine:

def function_with_six_roots(x):
    return (x - 1) * (x - 2) * (x - 3) * (x - 4) * (x - 5)* (x - 6)

left_extremal = extremal_root(
    function_with_six_roots,
    xL=-100,
    xR=100,
    which="left")

though this will fail without readjusting the step size:

def function_with_six_small_roots(x):
    return (x - 1e-5) * (x - 2e-5) * (x - 3e-5) * (x - 4e-5) * (x - 5e-5)* (x - 6e-5)

left_extremal = extremal_root(
    function_with_six_small_roots,
    xL=-100,
    xR=100,
    which="left",)

Do you think there is a sensible way to make this a bit more robust?

[dachengx]

I played with it a little bit and it' quite easy to find a case in which this produces RuntimeError: No root found in interval: This works fine:

def function_with_six_roots(x):
    return (x - 1) * (x - 2) * (x - 3) * (x - 4) * (x - 5)* (x - 6)

left_extremal = extremal_root(
    function_with_six_roots,
    xL=-100,
    xR=100,
    which="left")

though this will fail without readjusting the step size:

def function_with_six_small_roots(x):
    return (x - 1e-5) * (x - 2e-5) * (x - 3e-5) * (x - 4e-5) * (x - 5e-5)* (x - 6e-5)

left_extremal = extremal_root(
    function_with_six_small_roots,
    xL=-100,
    xR=100,
    which="left",)

Do you think there is a sensible way to make this a bit more robust?

Maybe 1% of the parameter's boundary?

[hammannr]

Maybe 1% of the parameter's boundary?
This could work but sometimes people (including myself) use relatively large parameter bounds to ensure the limits are well within. So also there would be some source of stability. This seems like it should be a solved problem, though.

[dachengx]

Maybe 1% of the parameter's boundary?
This could work but sometimes people (including myself) use relatively large parameter bounds to ensure the limits are well within. So also there would be some source of stability. This seems like it should be a solved problem, though.

I hope the analysts will figure out how to scale the parameter of interest to be within meaningful values. I will print a warning when the step is too large/small compared to the poi's boundary.