Comments on: Purpose of inv

By: Loren

Loren — Mon, 06 Jun 2011 10:47:30 +0000

Md. Ariful islam-

Best off using the operator \. It will yieldthe numerically best solution. inv is likely to NEVER be the best way, or the fastest.

–Loren

By: Md. Ariful islam

Md. Ariful islam — Fri, 03 Jun 2011 20:24:51 +0000

which on is faster to solve Ax=b. Inverse or Lu decompose

By: Tim Davis

Tim Davis — Wed, 18 Nov 2009 17:18:23 +0000

If you want to use something that acts like the inverse, but isn’t the inverse, see the FACTORIZE, an object-oriented method:

http://blogs.mathworks.com/pick/2009/06/26/dont-let-that-inv-go-past-your-eyes-to-solve-that-system-factorize/

It lets you write:

S = inverse(A)
x = S*b

but it does not actually compute the inverse. It does the right thing instead, by factorizing A and then using forward/backsolves to compute x=S*b.

So to solve (A+B*inv(C)*D)x=b do this:

S = inverse (A+B*inverse(C)*D) ;
x = S\b ;

and rest assured that you are not actually multiplying by the inverse.

By: Huapeng

Huapeng — Tue, 21 Apr 2009 06:11:31 +0000

I think it is necessary to keep this function. There are cases where we want to solve Ax=b with vector b variing. If the matrix A is of small dimension, it may be advantageous to calculate and store the inversion of the matrix A. In this way, there is no need to sovle the linear equation again when b varies. I usually write my program in this way. If it is silly, welcome your comments. Thanks!

By: William Roberts

William Roberts — Tue, 06 Nov 2007 15:07:21 +0000

I can’t see how to calculate the likelihood of a Gaussian vector with arbitrary covariance with out using inv. Unless, of course, you have the eigen-decomposition of the covariance.

By: Hamid Dehghani

Hamid Dehghani — Wed, 15 Aug 2007 09:24:00 +0000

I have been reading these with interest and am wondering if anyone can help with my problem.
I have a system of equations:
(A+B*inv(C)*D)x=b
where A, B, C and D are large (50,000 x 50,000) sparse (all banded or all dense depending on ‘optimization’) matricec and I have multiple right hand sides (i.e. b is a size of 20×1).
So, I should never ever calculate inv(C). so what can I do that is computationally fast and efficient?

By: Tim Davis

Tim Davis — Mon, 04 Jun 2007 17:25:05 +0000

Regarding the use of inv(D) when D is sparse and diagonal – a colleague reminded me of another option. The following three operations compute the same thing (x1, x2, x3):

n = 1000000 ;
b = rand(n,1);
d = rand(n,1);
D = spdiags (d, 0, n,n) ;
S = inv (D) ;
tic ; x1 = D\b ; toc
tic ; x2 = d .\ b ; toc
tic ; x3 = S*b ; toc

norm (x1-x2)
norm (x1-x3)

The latter two options (d.\b and S*b) are equally fast on my Intel Core Duo (MATLAB 7.4), whereas D\b takes about 50% more time. In fact, d.\b is a teeny bit faster than S*b. Using S*b is numerically dubious, of course. So even for diagonal matrices, there’s no need to use inv(D)*b. To scale the columns of b, use b./d instead of b/D or b*inv(D).

Richard’s example:

x = b’ * (inv(D)).^2 * b

can be written cleanly as

x = b’ * (diag(D)).^2 .\ b ;

the latter is faster. Even faster is
d = full(diag(D)) ;
x = b’ * (d.^2 .\b) ;

By: Roger Jeurissen

Roger Jeurissen — Wed, 30 May 2007 11:46:07 +0000

There is another use of inv that has not been mentioned: inverting a symbolic matrix. In my case, this was required for computing finite difference expressions from the Taylor series expansion around collocation points. That was the only time I have ever used inv, but it was useful. Greetings,
Roger.

By: Andriy

Andriy — Wed, 30 May 2007 01:32:25 +0000

It is really a bit off topic. Tim, thank you anyway.

By: Tim Davis

Tim Davis — Wed, 30 May 2007 01:18:49 +0000

Oh, the “you may use this code only if you promise not to use inv(A) to solve Ax=b” license was tongue-in-cheek, of course.

Briefly (“Briefly?!” as anyone who knows me will gasp), if all entries in d(t) change at each time step, then it’s a rank-n update and there’s nothing you can do that I know of but to completely refactorize the matrix. You can reuse the symbolic analysis if the pattern doesn’t change, but MATLAB doesn’t support that except to reuse the fill-reducing ordering (which CHOL computes efficiently anyway…). So there’s little to gain … but we’re getting off topic and I’ve already spammed Loren’s blog a little too much … so drop me an email if you have questions.