Integrate in a if statement? (python)

Question

Is it possible for me to integrate but set my integration limits in a loop? So, for instance, integrate my function from 8 to 8.9 until it reaches a value of 2.5? Thank you!

f1 = lambda x,c : c/x
integrate1=quad(f, 8,8.97, args=c1)
print(integrate1)

Maybe?

for index in range(8,9):
    f1 = lambda x,c: c/x
    integrate1 = quad(f, index, index+0.1, args=c1)
    print(integrate1)

Answer 1

Well, obviously you can do that:

import numpy as np
import scipy.integrate as si

def test_fn(x, c):
    return c / x

def main():
    lower_limit =  8.0
    target_area =  2.5
    c_val       = 42.0
    for upper_limit in np.arange(8., 10., 0.1):
        area = si.quad(test_fn, lower_limit, upper_limit, args=(c_val,))
        if area >= target_area:
            print("Area is {} at ul={}".format(area, upper_limit))
            break

if __name__=="__main__":
    main()

but your step interval limits your result accuracy, and you're doing an awful lot of unnecessary calculations (== slow).

As @Jakob_Weisblat says, you can switch to a binary search algorithm. That's faster, but you have to do some extra bookkeeping. Why not delegate?

I suggest turning it into a metaproblem: solve for the upper limit such that integrating results in your desired target value:

import functools
import scipy.integrate as si
import scipy.optimize as so

def test_fn(x, c):
    return c / x

def integrate_fn(ul, fn, ll, args, target):
    return si.quad(fn, ll, ul, args=args) - target

def main():
    lower_limit =  8.0
    target_area =  2.5
    c_val       = 42.0
    sol = so.brentq(
        integrate_fn, lower_limit, 20.0, args=(
            test_fn, lower_limit, (c_val,), target_area
        )
    )
    print(sol)

if __name__=="__main__":
    main()

(Do note that this code is untested, as this machine does not have scipy installed.)

Answer 2

for a non-integer loop with a fixed step you may do something like that:

for val in xrange(80, 90):
    val /= 10
    ........

or

val = 8.0
while val<8.9:
    <do your worst>
    val += step

Rounding on the way may be good idea - to get required precision