The Integral Calculator lets you calculate integrals and antiderivatives of functions online — for free!
Our calculator allows you to check your solutions to calculus exercises. It helps you practice by showing you the full working (step by step integration). All common integration techniques and even special functions are supported.
The Integral Calculator supports definite and indefinite integrals (antiderivatives) as well as integrating functions with many variables. You can also check your answers! Interactive graphs/plots help visualize and better understand the functions.
For more about how to use the Integral Calculator, go to 'Help' or take a look at the examples.
Integral driver: feed cord into fixture and splice wires in driver compartment. Follow joining detail instructions where fixtures are joined. Your SSO login does not have any Sold-To’s associated to it. To experience the features of Avaya's Support website, associate a Sold To to your SSO login, click here to learn how.
And now: Happy integrating!
Enter the function you want to integrate into the Integral Calculator. Skip the 'f(x) =' part! The Integral Calculator will show you a graphical version of your input while you type. Make sure that it shows exactly what you want. Use parentheses, if necessary, e. g. 'a/(b+c)'.
In 'Examples', you can see which functions are supported by the Integral Calculator and how to use them.
When you're done entering your function, click 'Go!', and the Integral Calculator will show the result below.
In 'Options', you can set the variable of integration and the integration bounds. If you don't specify the bounds, only the antiderivative will be computed.
Clicking an example enters it into the Integral Calculator. Moving the mouse over it shows the text.
Configure the Integral Calculator:
The practice problem generator allows you to generate as many random exercises as you want.
You find some configuration options and a proposed problem below. You can accept it (then it's input into the calculator) or generate a new one.
This will be calculated:
Loading … please wait! |
Not what you mean? Use parentheses! Set integration variable and bounds in 'Options'.
Recommend this Website
If you like this website, then please support it by giving it a Like. Thank you!
Book Recommendation
Calculus for Dummies (2nd Edition)
An extremely well-written book for students taking Calculus for the first time as well as those who need a refresher. This book makes you realize that Calculus isn't that tough after all. → to the book
Paid link. As an Amazon Associate I earn from qualifying purchases.
Result
How the Integral Calculator Works
For those with a technical background, the following section explains how the Integral Calculator works.
First, a parser analyzes the mathematical function. It transforms it into a form that is better understandable by a computer, namely a tree (see figure below). In doing this, the Integral Calculator has to respect the order of operations. A specialty in mathematical expressions is that the multiplication sign can be left out sometimes, for example we write '5x' instead of '5*x'. The Integral Calculator has to detect these cases and insert the multiplication sign.
The parser is implemented in JavaScript, based on the Shunting-yard algorithm, and can run directly in the browser. This allows for quick feedback while typing by transforming the tree into LaTeX code. MathJax takes care of displaying it in the browser.
When the 'Go!' button is clicked, the Integral Calculator sends the mathematical function and the settings (variable of integration and integration bounds) to the server, where it is analyzed again. This time, the function gets transformed into a form that can be understood by the computer algebra systemMaxima.
Maxima takes care of actually computing the integral of the mathematical function. Maxima's output is transformed to LaTeX again and is then presented to the user. The antiderivative is computed using the Risch algorithm, which is hard to understand for humans. That's why showing the steps of calculation is very challenging for integrals.
In order to show the steps, the calculator applies the same integration techniques that a human would apply. The program that does this has been developed over several years and is written in Maxima's own programming language. It consists of more than 17000 lines of code. When the integrand matches a known form, it applies fixed rules to solve the integral (e. g. partial fraction decomposition for rational functions, trigonometric substitution for integrands involving the square roots of a quadratic polynomial or integration by parts for products of certain functions). Otherwise, it tries different substitutions and transformations until either the integral is solved, time runs out or there is nothing left to try. The calculator lacks the mathematical intuition that is very useful for finding an antiderivative, but on the other hand it can try a large number of possibilities within a short amount of time. The step by step antiderivatives are often much shorter and more elegant than those found by Maxima.
The 'Check answer' feature has to solve the difficult task of determining whether two mathematical expressions are equivalent. Their difference is computed and simplified as far as possible using Maxima. For example, this involves writing trigonometric/hyperbolic functions in their exponential forms. If it can be shown that the difference simplifies to zero, the task is solved. Otherwise, a probabilistic algorithm is applied that evaluates and compares both functions at randomly chosen places. In the case of antiderivatives, the entire procedure is repeated with each function's derivative, since antiderivatives are allowed to differ by a constant.
The interactive function graphs are computed in the browser and displayed within a canvas element (HTML5). For each function to be graphed, the calculator creates a JavaScript function, which is then evaluated in small steps in order to draw the graph. While graphing, singularities (e. g. poles) are detected and treated specially. The gesture control is implemented using Hammer.js.
If you have any questions or ideas for improvements to the Integral Calculator, don't hesitate to write me an e-mail.
Proportional Integral (PI) Control
A variation of Proportional Integral Derivative (PID) control is to use only the proportional and integral terms as PI control. The PI controller is the most popular variation, even more than full PID controllers. The value of the controller output `u(t)` is fed into the system as the manipulated variable input.
$$e(t) = SP-PV$$
$$u(t) = u_{bias} + K_c , e(t) + frac{K_c}{tau_I}int_0^t e(t)dt$$
The `u_{bias}` term is a constant that is typically set to the value of `u(t)` when the controller is first switched from manual to automatic mode. This gives 'bumpless' transfer if the error is zero when the controller is turned on. The two tuning values for a PI controller are the controller gain, `K_c` and the integral time constant `tau_I`. The value of `K_c` is a multiplier on the proportional error and integral term and a higher value makes the controller more aggressive at responding to errors away from the set point. The set point (SP) is the target value and process variable (PV) is the measured value that may deviate from the desired value. The error from the set point is the difference between the SP and PV and is defined as `e(t) = SP - PV`.
Discrete PI Controller
Digital controllers are implemented with discrete sampling periods and a discrete form of the PI equation is needed to approximate the integral of the error. This modification replaces the continuous form of the integral with a summation of the error and uses `Delta t` as the time between sampling instances and `n_t` as the number of sampling instances.
$$u(t) = u_{bias} + K_c , e(t) + frac{K_c}{tau_I}sum_{i=1}^{n_t} e_i(t)Delta t$$
Overview of PI Control
PI control is needed for non-integrating processes, meaning any process that eventually returns to the same output given the same set of inputs and disturbances. A P-only controller is best suited to integrating processes. Integral action is used to remove offset and can be thought of as an adjustable `u_{bias}`.
.jpg?format=1500w "Integral driver")
Common tuning correlations for PI control are the ITAE (Integral of Time-weighted Absolute Error) method and IMC (Internal Model Control). IMC is an extension of lambda tuning by accounting for time delay. The parameters `K_c`, `tau_p`, and `theta_p` are obtained by fitting dynamic input and output data to a first-order plus dead-time (FOPDT) model.
IMC Tuning Correlations
$$mathrm{Aggressive,Tuning:} quad tau_c = max left( 0.1 tau_p, 0.8 theta_p right)$$
$$mathrm{Moderate,Tuning:} quad tau_c = max left( 1.0 tau_p, 8.0 theta_p right)$$
$$mathrm{Conservative,Tuning:} quad tau_c = max left( 10.0 tau_p, 80.0 theta_p right)$$
$$K_c = frac{1}{K_p}frac{tau_p}{left( theta_p + tau_c right)} quad quad tau_I = tau_p$$
Note that with moderate tuning and negligible dead-time `(theta_p to 0 ' and ' tau_c = 1.0 tau_p)`, IMC reduces to simple tuning correlations that are easy to recall without a reference book.
$$K_c = frac{1}{K_p} quad quad tau_I = tau_p quad quad mathrm{Simple,tuning,correlations}$$
ITAE Tuning Correlations
Different tuning correlations are provided for disturbance rejection (also referred to as regulatory control) and set point tracking (also referred to as servo control).
$$K_c = frac{0.586}{K_p}left(frac{theta_p}{tau_p}right)^{-0.916} quad tau_I = frac{tau_p}{1.03-0.165left(theta_p/tau_pright)}quadmathrm{Set;point;tracking}$$
$$K_c = frac{0.859}{K_p}left(frac{theta_p}{tau_p}right)^{-0.977} quad tau_I = frac{tau_p}{0.674}left(frac{theta_p}{tau_p}right)^{0.680}quadmathrm{Disturbance;rejection}$$
Anti-Reset Windup
An important feature of a controller with an integral term is to consider the case where the controller output `u(t)` saturates at an upper or lower bound for an extended period of time. This causes the integral term to accumulate to a large summation that causes the controller to stay at the saturation limit until the integral summation is reduced. Anti-reset windup is that the integral term does not accumulate if the controller output is saturated at an upper or lower limit.
Suppose that a driver of a vehicle set the desired speed set point to a value higher than the maximum speed. The automatic controller would saturate at full throttle and stay there until the driver lowered the set point. Suppose that the driver kept the speed set point higher than the maximum velocity of the vehicle for an hour. The discrepancy between the set point and the current speed would create a large integral term. If the driver then set the speed set point to zero, the controller would wait to lower the throttle until the negative error cancels out the positive error from the hour of driving. The automobile would not slow down but continue at full throttle for an extended period of time. This undesirable behavior is fixed by implementing anti-reset windup.
Exercise
The purpose of this exercise is to investigate the cause of offset in a P-only controller and oscillations in a PI controller.
Integral Driver Meaning
Open Loop Response
Consider a first order plus dead time process as
$$tau_p frac{dy}{dt} = -y + K_p u left(t-theta_pright)$$
with `K_p = 2`, `tau_p = 200`, and `theta_p = 0`. Simulate the behavior for making a step change in manual mode from 0 to 10 (and back). Explain what happens in terms of oscillations or a smooth response.
P-only Control
Simulate the behavior for using a P-only controller with `K_c = 2` and `K_c=0.5`. Implement a set point change from 0 to 10 and back in automatic mode (closed-loop). Include a plot of the error between the set point (SP) and process variable (PV). What happens with increased `K_c` in terms of offset and oscillation?
PI Control
Configure the controller to add an integral term in addition to the proportional control with `K_c = 2`. Simulate the PI controller response with integral reset times `tau_I=200, 100, 10`. Include a plot of the integral of the error between the set point (SP) and process variable (PV) with anti-reset windup. Explain what happens and why.
Open Loop Response with Dead Time
Add dead time `theta_p=100` as an input delay. Simulate the behavior for making a step change in manual mode from 0 to 10 (and back). Explain what happens in terms of oscillations.
P-only Control with Dead Time
With the dead time, simulate the response of a P-only controller with `K_c=2` and `K_c=0.5`. Implement a set point change from 0 to 10 and back in automatic mode (closed-loop). Include a plot of the error between the set point (SP) and process variable (PV). What happens with increased `K_c` in terms of offset and oscillation?
Integral Driver Vs Remote Driver
PI Control with Dead Time
Simulate the response of a PI controller with `tau_I=200`. Include a plot of the integral of the error between the set point (SP) and process variable (PV) with anti-reset windup. Explain what happens and why. Explain the results.
Summary Questions
- Based on the observations in manual mode, is the process stable or unstable?
- Why does P-only control have persistent offset?
- What is the effect of dead time on P-only and PI control?
- If the process is stable, why can the control system make it unstable?
Sample Code
Integral Dimmable Driver
import matplotlib.pyplotas plt
from scipy.integrateimport odeint
# specify number of steps
ns =1200
# define time points
t = np.linspace(0,ns,ns+1)
# mode (manual=0, automatic=1)
mode =1
class model(object):
# process model
Kp =2.0
taup =200.0
thetap =0.0
class pid(object):
# PID tuning
Kc =2.0
tauI =10.0
tauD =0
sp =[]
# Define Set Point
sp = np.zeros(ns+1)# set point
sp[50:600]=10
sp[600:]=0
pid.sp= sp
def process(y,t,u,Kp,taup):
# Kp = process gain
# taup = process time constant
dydt = -y/taup + Kp/taup * u
return dydt
def calc_response(t,mode,xm,xc):
# t = time points
# mode (manual=0, automatic=1)
# process model
Kp = xm.Kp
taup = xm.taup
thetap = xm.thetap
# specify number of steps
ns =len(t)-1
# PID tuning
Kc = xc.Kc
tauI = xc.tauI
tauD = xc.tauD
sp = xc.sp# set point
delta_t = t[1]-t[0]
# storage for recording values
op = np.zeros(ns+1)# controller output
pv = np.zeros(ns+1)# process variable
e = np.zeros(ns+1)# error
ie = np.zeros(ns+1)# integral of the error
dpv = np.zeros(ns+1)# derivative of the pv
P = np.zeros(ns+1)# proportional
I = np.zeros(ns+1)# integral
D = np.zeros(ns+1)# derivative
# step input for manual control
if mode0:
op[100:]=2
# Upper and Lower limits on OP
op_hi =100.0
op_lo =0.0
# Simulate time delay
ndelay =int(np.ceil(thetap / delta_t))
# loop through time steps
for i inrange(0,ns):
e[i]= sp[i] - pv[i]
if i >=1: # calculate starting on second cycle
dpv[i]=(pv[i]-pv[i-1])/delta_t
ie[i]= ie[i-1] + e[i] * delta_t
P[i]= Kc * e[i]
I[i]= Kc/tauI * ie[i]
D[i]= - Kc * tauD * dpv[i]
if mode1:
op[i]= op[0] + P[i] + I[i] + D[i]
if op[i]> op_hi: # check upper limit
op[i]= op_hi
ie[i]= ie[i] - e[i] * delta_t # anti-reset windup
if op[i]< op_lo: # check lower limit
op[i]= op_lo
ie[i]= ie[i] - e[i] * delta_t # anti-reset windup
# implement time delay
iop =max(0,i-ndelay)
y = odeint(process,pv[i],[0,delta_t],args=(op[iop],Kp,taup))
pv[i+1]= y[-1]
op[ns]= op[ns-1]
ie[ns]= ie[ns-1]
P[ns]= P[ns-1]
I[ns]= I[ns-1]
D[ns]= D[ns-1]
return(pv,op)
def plot_response(n,mode,t,pv,op,sp):
# plot results
plt.figure(n)
plt.subplot(2,1,1)
if(mode1):
plt.plot(t,sp,'k-',linewidth=2,label='Set Point (SP)')
plt.plot(t,pv,'b--',linewidth=3,label='Process Variable (PV)')
plt.legend(loc='best')
plt.ylabel('Process Output')
plt.subplot(2,1,2)
plt.plot(t,op,'r:',linewidth=3,label='Controller Output (OP)')
plt.legend(loc='best')
plt.ylabel('Process Input')
plt.xlabel('Time')
# calculate step response
model.Kp=2.0
model.taup=200.0
model.thetap=0.0
mode =0
(pv,op)= calc_response(t,mode,model,pid)
plot_response(1,mode,t,pv,op,sp)
# PI control
pid.Kc=2.0
pid.tauI=10.0
pid.tauD=0.0
mode =1
(pv,op)= calc_response(t,mode,model,pid)
plot_response(2,mode,t,pv,op,sp)
plt.show()
Assignment
See Velocity PI Control