This is machine translation

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

Note: This page has been translated by MathWorks. Please click here
To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

Inverses and Determinants


If A is square and nonsingular, the equations AX = I and XA = I have the same solution, X. This solution is called the inverse of A, is denoted by A-1, and is computed by the function inv.

The determinant of a matrix is useful in theoretical considerations and some types of symbolic computation, but its scaling and round-off error properties make it far less satisfactory for numeric computation. Nevertheless, the function det computes the determinant of a square matrix:

A = pascal(3)

A =
       1     1     1
       1     2     3
       1     3     6
d = det(A)
X = inv(A)

d =

X = 
       3    -3     1
      -3     5    -2
       1    -2     1

Again, because A is symmetric, has integer elements, and has determinant equal to one, so does its inverse. However,

B = magic(3)

B =
       8     1     6
       3     5     7
       4     9     2
d = det(B)
X = inv(B)

d =

X =
      0.1472   -0.1444    0.0639
     -0.0611    0.0222    0.1056
     -0.0194    0.1889   -0.1028

Closer examination of the elements of X, or use of format rat, would reveal that they are integers divided by 360.

If A is square and nonsingular, then, without round-off error, X = inv(A)*B is theoretically the same as X = A\B and Y = B*inv(A) is theoretically the same as Y = B/A. But the computations involving the backslash and slash operators are preferable because they require less computer time, less memory, and have better error-detection properties.


Rectangular matrices do not have inverses or determinants. At least one of the equations AX = I and XA = I does not have a solution. A partial replacement for the inverse is provided by the Moore-Penrose pseudoinverse, which is computed by the pinv function:

format short
C = fix(10*gallery('uniformdata',[3 2],0));
X = pinv(C)

X =
    0.1159   -0.0729    0.0171
   -0.0534    0.1152    0.0418

The matrix

Q = X*C

Q =
    1.0000    0.0000
    0.0000    1.0000

is the 2-by-2 identity, but the matrix

P = C*X

P =
    0.8293   -0.1958    0.3213
   -0.1958    0.7754    0.3685
    0.3213    0.3685    0.3952

is not the 3-by-3 identity. However, P acts like an identity on a portion of the space in the sense that P is symmetric, P*C is equal to C, and X*P is equal to X.

Solving a Rank-Deficient System

If A is m-by-n with m > n and full rank n, each of the three statements

x = A\b
x = pinv(A)*b
x = inv(A'*A)*A'*b

theoretically computes the same least-squares solution x, although the backslash operator does it faster.

However, if A does not have full rank, the solution to the least-squares problem is not unique. There are many vectors x that minimize

norm(A*x -b)

The solution computed by x = A\b is a basic solution; it has at most r nonzero components, where r is the rank of A. The solution computed by x = pinv(A)*b is the minimal norm solution because it minimizes norm(x). An attempt to compute a solution with x = inv(A'*A)*A'*b fails because A'*A is singular.

Here is an example that illustrates the various solutions:

A = [ 1  2  3
      4  5  6
      7  8  9
     10 11 12 ];

does not have full rank. Its second column is the average of the first and third columns. If

b = A(:,2)

is the second column, then an obvious solution to A*x = b is x = [0 1 0]'. But none of the approaches computes that x. The backslash operator gives

x = A\b

Warning: Rank deficient, rank = 2, tol = 1.4594e-014.
x =

This solution has two nonzero components. The pseudoinverse approach gives

y = pinv(A)*b

y =

There is no warning about rank deficiency. But norm(y) = 0.5774 is less than norm(x) = 0.7071. Finally,

z = inv(A'*A)*A'*b

fails completely:

Warning: Matrix is close to singular or badly scaled.
         Results may be inaccurate. RCOND = 9.868649e-018. 
z =


LAPACK is a library of routines that provides fast, robust algorithms for numerical linear algebra and matrix computations. Since the year 2000, linear algebra functions and matrix operations in MATLAB® are built on LAPACK, and they continue to benefit from the performance and accuracy of its routines.

Was this topic helpful?