# int

Definite and indefinite integrals

## Syntax

``F = int(expr)``
``F = int(expr,var)``
``F = int(expr,a,b)``
``F = int(expr,var,a,b)``
``F = int(___,Name,Value)``

## Description

example

````F = int(expr)` computes the indefinite integral of `expr`. `int` uses the default integration variable determined by `symvar`(`expr,1`). If `expr` is a constant, then the default integration variable is `x`.```

example

````F = int(expr,var)` computes the indefinite integral of `expr` with respect to the symbolic scalar variable `var`.```

example

````F = int(expr,a,b)` computes the definite integral of `expr` from `a` to `b`. `int` uses the default integration variable determined by `symvar`(`expr,1`). If `expr` is a constant, then the default integration variable is `x`. `int(expr,[a b])` is equivalent to `int(expr,a,b)`.```

example

````F = int(expr,var,a,b)` computes the definite integral of `expr` with respect to the symbolic scalar variable `var` from `a` to `b`. `int(expr,var,[a b])` is equivalent to `int(expr,var,a,b)`.```

example

````F = int(___,Name,Value)` specifies additional options using one or more `Name,Value` pair arguments. For example, `'IgnoreAnalyticConstraints',true` specifies that `int` applies additional simplifications to the integrand.```

## Examples

collapse all

Define a univariate expression.

```syms x expr = -2*x/(1+x^2)^2;```

Find the indefinite integral of the univariate expression.

`F = int(expr)`
```F =  $\frac{1}{{x}^{2}+1}$```

Define a multivariate function with variables `x` and `z`.

```syms x z f(x,z) = x/(1+z^2);```

Find the indefinite integrals of the multivariate expression with respect to the variables `x` and `z`.

`Fx = int(f,x)`
```Fx(x, z) =  $\frac{{x}^{2}}{2 \left({z}^{2}+1\right)}$```
`Fz = int(f,z)`
`Fz(x, z) = $x \mathrm{atan}\left(z\right)$`

If you do not specify the integration variable, then `int` uses the first variable returned by `symvar` as the integration variable.

`var = symvar(f,1)`
`var = $x$`
`F = int(f)`
```F(x, z) =  $\frac{{x}^{2}}{2 \left({z}^{2}+1\right)}$```

Integrate a symbolic expression from `0` to `1`.

```syms x expr = x*log(1+x); F = int(expr,[0 1])```
```F =  $\frac{1}{4}$```

Integrate another expression from `sin(t)` to `1`.

```syms t F = int(2*x,[sin(t) 1])```
`F = ${\mathrm{cos}\left(t\right)}^{2}$`

When `int` cannot compute the value of a definite integral, numerically approximate the integral by using `vpa`.

```syms x f = cos(x)/sqrt(1 + x^2); Fint = int(f,x,[0 10])```
```Fint =  ${\int }_{0}^{10}\frac{\mathrm{cos}\left(x\right)}{\sqrt{{x}^{2}+1}}\mathrm{d}x$```
`Fvpa = vpa(Fint)`
`Fvpa = $0.37570628299079723478493405557162$`

To approximate integrals directly, use `vpaintegral` instead of `vpa`. The `vpaintegral` function is faster and provides control over integration tolerances.

`Fvpaint = vpaintegral(f,x,[0 10])`
`Fvpaint = $0.375706$`

Define a symbolic matrix containing four expressions as its elements.

```syms a x t z M = [exp(t) exp(a*t); sin(t) cos(t)]```
```M =  $\left(\begin{array}{cc}{\mathrm{e}}^{t}& {\mathrm{e}}^{a t}\\ \mathrm{sin}\left(t\right)& \mathrm{cos}\left(t\right)\end{array}\right)$```

Find indefinite integrals of the matrix element-wise.

`F = int(M,t)`
```F =  $\left(\begin{array}{cc}{\mathrm{e}}^{t}& \frac{{\mathrm{e}}^{a t}}{a}\\ -\mathrm{cos}\left(t\right)& \mathrm{sin}\left(t\right)\end{array}\right)$```

Define a symbolic function and compute its indefinite integral.

```syms f(x) f(x) = acos(cos(x)); F = int(f,x)```
```F(x) =  $x \mathrm{acos}\left(\mathrm{cos}\left(x\right)\right)-\frac{{x}^{2}}{2 \mathrm{sign}\left(\mathrm{sin}\left(x\right)\right)}$```

By default, `int` uses strict mathematical rules. These rules do not let `int` rewrite `acos(cos(x))` as `x`.

If you want a simple practical solution, set `'IgnoreAnalyticConstraints'` to `true`.

`F = int(f,x,'IgnoreAnalyticConstraints',true)`
```F(x) =  $\frac{{x}^{2}}{2}$```

Define a symbolic expression ${\mathit{x}}^{\mathit{t}}$ and compute its indefinite integral with respect to the variable $x$.

```syms x t F = int(x^t,x)```
```F =  ```

By default, `int` returns the general results for all values of the other symbolic parameter `t`. In this example, `int` returns two integral results for the case $t=-1$ and $t\ne -1$.

To ignore special cases of parameter values, set `'IgnoreSpecialCases'` to `true`. With this option, `int` ignores the special case $t=-1$ and returns the solution for $t\ne -1$.

`F = int(x^t,x,'IgnoreSpecialCases',true)`
```F =  $\frac{{x}^{t+1}}{t+1}$```

Define a symbolic function $f\left(x\right)=1/\left(x-1\right)$ that has a pole at $x=1$.

```syms x f(x) = 1/(x-1)```
```f(x) =  $\frac{1}{x-1}$```

Compute the definite integral of this function from $x=0$ to $x=2$. Since the integration interval includes the pole, the result is not defined.

`F = int(f,[0 2])`
`F = $\mathrm{NaN}$`

However, the Cauchy principal value of the integral exists. To compute the Cauchy principal value of the integral, set `'PrincipalValue'` to `true`.

`F = int(f,[0 2],'PrincipalValue',true)`
`F = $0$`

Find the integral of $\int \mathit{x}\text{\hspace{0.17em}}{\mathit{e}}^{\mathit{x}}\text{\hspace{0.17em}}\mathit{dx}$.

Define the integral without evaluating it by setting the `'Hold'` option to `true`.

```syms x g(y) F = int(x*exp(x),'Hold',true)```
```F =  $\int x {\mathrm{e}}^{x}\mathrm{d}x$```

You can apply integration by parts to `F` by using the `integrateByParts` function. Use `exp(x)` as the differential to be integrated.

`G = integrateByParts(F,exp(x))`
```G =  $x {\mathrm{e}}^{x}-\int {\mathrm{e}}^{x}\mathrm{d}x$```

To evaluate the integral in `G`, use the `release` function to ignore the `'Hold'` option.

`Gcalc = release(G)`
`Gcalc = $x {\mathrm{e}}^{x}-{\mathrm{e}}^{x}$`

Compare the result to the integration result returned by `int` without setting the `'Hold'` option.

`Fcalc = int(x*exp(x))`
`Fcalc = ${\mathrm{e}}^{x} \left(x-1\right)$`

If `int` cannot compute a closed form of an integral, then it returns an unresolved integral.

```syms f(x) f(x) = sin(sinh(x)); F = int(f,x)```
```F(x) =  $\int \mathrm{sin}\left(\mathrm{sinh}\left(x\right)\right)\mathrm{d}x$```

You can approximate the integrand function $f\left(x\right)$ as polynomials by using the Taylor expansion. Apply `taylor` to expand the integrand function $f\left(x\right)$ as polynomials around $x=0$. Compute the integral of the approximated polynomials.

`fTaylor = taylor(f,x,'ExpansionPoint',0,'Order',10)`
```fTaylor(x) =  $\frac{{x}^{9}}{5670}-\frac{{x}^{7}}{90}-\frac{{x}^{5}}{15}+x$```
`Fapprox = int(fTaylor,x)`
```Fapprox(x) =  $\frac{{x}^{10}}{56700}-\frac{{x}^{8}}{720}-\frac{{x}^{6}}{90}+\frac{{x}^{2}}{2}$```

## Input Arguments

collapse all

Integrand, specified as a symbolic expression, function, vector, matrix, or number.

Integration variable, specified as a symbolic variable. If you do not specify this variable, `int` uses the default variable determined by `symvar(expr,1)`. If `expr` is a constant, then the default variable is `x`.

Lower bound, specified as a number, symbolic number, variable, expression, or function (including expressions and functions with infinities).

Upper bound, specified as a number, symbolic number, variable, expression, or function (including expressions and functions with infinities).

### Name-Value Arguments

Specify optional comma-separated pairs of `Name,Value` arguments. `Name` is the argument name and `Value` is the corresponding value. `Name` must appear inside quotes. You can specify several name and value pair arguments in any order as `Name1,Value1,...,NameN,ValueN`.

Example: `'IgnoreAnalyticConstraints',true` specifies that `int` applies purely algebraic simplifications to the integrand.

Indicator for applying purely algebraic simplifications to the integrand, specified as `true` or `false`. If the value is `true`, apply purely algebraic simplifications to the integrand. This option can provide simpler results for expressions, for which the direct use of the integrator returns complicated results. In some cases, it also enables `int` to compute integrals that cannot be computed otherwise.

Using this option can lead to results not generally valid. This option applies mathematical identities that are convenient, but the results do not always hold for all values of variables.

Indicator for ignoring special cases, specified as `true` or `false`. This ignores cases that require one or more parameters to be elements of a comparatively small set, such as a fixed finite set or a set of integers.

Indicator for returning the principal value, specified as `true` or `false`. If the value is `true`, compute the Cauchy principal value of the integral. In live script, the Cauchy principal value of unevaluated integral shows as the symbol.

Indicator for unevaluated integration, specified as `true` or `false`. If the value is `true`, `int` returns integrals without evaluating them.

## Tips

• In contrast to differentiation, symbolic integration is a more complicated task. If `int` cannot compute an integral of an expression, check for these reasons:

• The antiderivative does not exist in a closed form.

• The antiderivative exists, but `int` cannot find it.

If `int` cannot compute a closed form of an integral, it returns an unresolved integral.

Try approximating such integrals by using one of these methods:

• For indefinite integrals, use series expansions. Use this method to approximate an integral around a particular value of the variable.

• For definite integrals, use numeric approximations.

• For indefinite integrals, `int` does not return a constant of integration in the result. The results of integrating mathematically equivalent expressions may be different. For example, ```syms x; int((x+1)^2)``` returns `(x+1)^3/3`, while `syms x; int(x^2+2*x+1)` returns `(x*(x^2+3*x+3))/3`, which differs from the first result by `1/3`.

• For indefinite integrals, `int` implicitly assumes that the integration variable `var` is real. For definite integrals, `int` restricts the integration variable `var` to the specified integration interval. If one or both integration bounds `a` and `b` are not numeric, `int` assumes that `a <= b` unless you explicitly specify otherwise.

## Algorithms

When you use `IgnoreAnalyticConstraints`, `int` applies these rules:

• log(a) + log(b) = log(a·b) for all values of a and b. In particular, the following equality is valid for all values of a, b, and c:

(a·b)c = ac·bc.

• log(ab) = b·log(a) for all values of a and b. In particular, the following equality is valid for all values of a, b, and c:

(ab)c = ab·c.

• If f and g are standard mathematical functions and f(g(x)) = x for all small positive numbers, then f(g(x)) = x is assumed to be valid for all complex values x. In particular:

• log(ex) = x

• asin(sin(x)) = x, acos(cos(x)) = x, atan(tan(x)) = x

• asinh(sinh(x)) = x, acosh(cosh(x)) = x, atanh(tanh(x)) = x

• Wk(x·ex) = x for all branch indices k of the Lambert W function.