I have a convolution integral that has a similar form described in this post: ([link](https://stackoverflow.com/questions/15965040/python-numpy-convolve-to-solve-convolution-integral-with-limits-from-0-to-t-inst))

Instead of integrating from 0 to t, I need to integrate from minus infinity to t. I was not able to do this, however, using `numpy.convolve`, as it always return results from minus infinity to plus infinity.
Using `scipy.integrate.quad` would be very slow as I have to loop through every `t`, and it only works for integrands that have analytical expressions.

Is there a way to specify the lower and upper limits of `numpy.convolve`? Thank you very much.

Here is the code (I apologize for not be able to type LaTeX equation here):

```
import numpy as np
import matplotlib.pyplot as plt
from scipy import integrate

def gaussian(tau, mu, sigma):

    pdf = 1/(sigma * np.sqrt(2 * np.pi)) * np.exp( - (tau - mu)**2 / (2 * sigma**2))
    return pdf

def gaussian_deriv(tau, mu, sigma):
    """
    derivative of gaussian function
    """
    pdf = -(tau - mu)/sigma**2 * gaussian(tau, mu, sigma)
    return pdf

def integral_kernel(tau):
    return np.cbrt(1/tau)

def integrand(tau, t, mu, sigma):

    return gaussian_deriv(tau, mu, sigma) * integral_kernel(t - tau + 1E-28)

tau = np.linspace(-7, 7, 1000)
dtau = tau[1] - tau[0]
lower_lim = tau[0]
g_deriv = gaussian_deriv(tau, mu=0, sigma=1)

result = np.zeros_like(tau)
for idx, t in np.ndenumerate(tau):
    result[idx], err = integrate.quad(integrand, lower_lim, t, args=(t, mu, sigma), points=[t])

result_convolve = np.convolve(g_deriv, integral_kernel(tau), mode='same') * dtau

fig, ax = plt.subplots(2,1, figsize=(10, 6))
ax[0].plot(tau, result, 'r-', label='scipy quad')
ax[1].plot(tau, result_convolve, '.', label='numpy convolve')
ax[0].legend()
ax[1].legend()
plt.show()

```