# Documentation

### This is machine translation

Translated by
Mouseover text to see original. Click the button below to return to the English version of the page.

Note: This page has been translated by MathWorks. Click here to see
To view all translated materials including this page, select Country from the country navigator on the bottom of this page.

# inv

Matrix inverse

## Syntax

``Y = inv(X)``

## Description

example

````Y = inv(X)` computes the inverse of square matrix `X`.`X^(-1)` is equivalent to `inv(X)`.`x = A\b` is computed differently than `x = inv(A)*b` and is recommended for solving systems of linear equations.```

## Examples

collapse all

Compute the inverse of a 3-by-3 matrix.

`X = [1 0 2; -1 5 0; 0 3 -9]`
```X = 3×3 1 0 2 -1 5 0 0 3 -9 ```
`Y = inv(X)`
```Y = 3×3 0.8824 -0.1176 0.1961 0.1765 0.1765 0.0392 0.0588 0.0588 -0.0980 ```

Check the results. Ideally, `Y*X` produces the identity matrix. Since `inv` performs the matrix inversion using floating-point computations, in practice `Y*X` is close to, but not exactly equal to, the identity matrix `eye(size(X))`.

`Y*X`
```ans = 3×3 1.0000 0.0000 -0.0000 0 1.0000 -0.0000 0 -0.0000 1.0000 ```

Examine why solving a linear system by inverting the matrix using `inv(A)*b` is inferior to solving it directly using the backslash operator, `x = A\b`.

Create a random matrix `A` of order 500 that is constructed so that its condition number, `cond(A)`, is `1e10`, and its norm, `norm(A)`, is `1`. The exact solution `x` is a random vector of length 500, and the right side is `b = A*x`. Thus the system of linear equations is badly conditioned, but consistent.

```n = 500; Q = orth(randn(n,n)); d = logspace(0,-10,n); A = Q*diag(d)*Q'; x = randn(n,1); b = A*x;```

Solve the linear system `A*x = b` by inverting the coefficient matrix `A`. Use `tic` and `toc` to get timing information.

```tic y = inv(A)*b; t = toc```
```t = 0.0209 ```

Find the absolute and residual error of the calculation.

`err_inv = norm(y-x)`
```err_inv = 5.0242e-06 ```
`res_inv = norm(A*y-b)`
```res_inv = 5.0540e-07 ```

Now, solve the same linear system using the backslash operator `\`.

```tic z = A\b; t1 = toc```
```t1 = 0.0138 ```
`err_bs = norm(z-x)`
```err_bs = 4.2092e-06 ```
`res_bs = norm(A*z-b)`
```res_bs = 3.4458e-15 ```

The backslash calculation is quicker and has less residual error by several orders of magnitude. The fact that `err_inv` and `err_bs` are both on the order of `1e-6` simply reflects the condition number of the matrix.

The behavior of this example is typical. Using `A\b` instead of `inv(A)*b` is two to three times faster, and produces residuals on the order of machine accuracy relative to the magnitude of the data.

## Input Arguments

collapse all

Input matrix, specified as a square matrix. If `X` is badly scaled or nearly singular, then the `inv` calculation loses numerical accuracy. Use `rcond` or `cond` to check the condition number of the matrix.

Data Types: `single` | `double`
Complex Number Support: Yes

## More About

collapse all

### Matrix Inverse

A matrix `X` is invertible if there exists a matrix `Y` of the same size such that $XY=YX={I}_{n}$, where ${I}_{n}$ is the `n`-by-`n` identity matrix. The matrix `Y` is called the inverse of `X`.

A matrix that has no inverse is singular. A square matrix is singular only when its determinant is exactly zero.

## Tips

• It is seldom necessary to form the explicit inverse of a matrix. A frequent misuse of `inv` arises when solving the system of linear equations Ax = b. One way to solve the equation is with `x = inv(A)*b`. A better way, from the standpoint of both execution time and numerical accuracy, is to use the matrix backslash operator `x = A\b`. This produces the solution using Gaussian elimination, without explicitly forming the inverse. See `mldivide` for further information.

## Algorithms

`inv` performs an LU decomposition of the input matrix (or an LDL decomposition if the input matrix is Hermitian). It then uses the results to form a linear system whose solution is the matrix inverse `inv(X)`. For sparse inputs, `inv(X)` creates a sparse identity matrix and uses backslash, `X\speye(size(X))`.

## See Also

#### Introduced before R2006a

Was this topic helpful?

#### The Manager's Guide to Solving the Big Data Conundrum

Download white paper