scipy.integrate.quad() without using lambda

Question

I am currently making a program that involves rectification. The only module that can do complex integration is Scipy with its scipy.integrate.quad() command. However, in my code, I need to have a variable that represents the function itself, since there will eventually be more different functions used in the rectification process that are derived by using the preceding equation. Every source that I have seen about the command either involves lambda or creating a definition that outputs an equation.You input the equation manually. So, my question is, is there any way to integrate it without doing that? Here's my code:

import scipy                                                   
import sympy
from scipy.integrate import quad

def rectify(smallestterm, nextsmallestterm, poly, coef, exp):
   test = rectification(coef,exp)
   a = quad(test, smallestterm, nextsmallestterm)
   print(a)
   a = a[0]
   dist = a/2
   return dist     
def test(x):
   return rectification(coef, exp)
def rectification(coef, exp):
   u = Poly(lint(coef,exp)) #Generated Equation
   b = u.all_coeffs()
   poly = b
   c = len(poly) - 1
   exponents = []
   while c + 1 > 0:
       exponents.append(c)
       c = c - 1
   poly = function(poly,exponents)   #Generated Equation in a form that can actually be used and identified as a function.
   return sqrt(1+(pow(diff(poly),2)))

Where coef is a list of the leading coefficients of a polynomial and exp is a list of the leading exponents of a polynomial. Essentially, they will both be indirectly combined in another definition, function(coef, exp) (code for it not shown) that outputs the polynomial (the variable "poly").

i.e.

function([2,4,5],[1,6,0]) Outputs

4*x**6 + 2*x + 5

This code (above the function code) does not work as it doesn't allow me to use the variable "a" to represent an entire function, as it only recognizes "a" as a function in itself. So, lambda does not work in my case. I can't simply do something like:

import scipy
import sympy
from scipy.integrate import quad
poly = 2*x**5 + 5*x**4 - 4*x**2 + 10   #Some complicated polynomial
d = diff(poly) #differential of polynomial
a = sqrt(1+(pow(d,2)))
e = quad(a, 1, 5)
e = e[1]/2
return e

If you need to see my full code to understand any other functions in this code, please do ask and I will happily provide it!

Answer 1

To my understanding, your code produces symbolic expressions using SymPy. These are not functions in the sense of Python, as they cannot be called. So they can't be used directly as the first argument of quad. SymPy provides lambdify method that wraps the expression into a function:

quad(lambdify(x, expr), 0, 1)

Here expr can be any symbolic expression with variable x in it, for example expr = 4*x**6 + 2*x + 5.