Question

I have a 3×3 matrix, A. I also compute a value, g, as the maximum eigen value of A. I am trying to change the element A(3,3) = 0 for all values from zero to one in 0.10 increments and then update g for each of the values. I’d like all of the other matrix elements to remain the same.

I thought a for loop would be the way to do this, but I do not know how to update only one element in a matrix without storing this update as one increasingly larger matrix. If I call the element at A(3,3) = p (thereby creating a new matrix Atry) I am able (below) to get all of the values from 0 to 1 that I desired. I do not know how to update Atry to get all of the values of g that I desire. The state of the code now will give me the same value of g for all iterations, as expected, as I do not know how to to update Atry with the different values of p to then compute the values for g.

Any suggestions on how to do this or suggestions for jargon or phrases for me to web search would be appreciated.

A = [1 1 1; 2 2 2; 3 3 0];  
g = max(eig(A));

% This below is what I attempted to achieve my solution
clear all  
p(1) = 0;
Atry = [1 1 1; 2 2 2; 3 3 p];  
g(1) = max(eig(Atry));  

for i=1:100;  
    p(i+1) = p(i)+ 0.01;
    % this makes a one giant matrix, not many  
    %Atry(:,i+1) = Atry(:,i); 
    g(i+1) = max(eig(Atry));  
end  

Answer 1

This will also accomplish what you want to do:

A = @(x) [1 1 1; 2 2 2; 3 3 x];
p = 0:0.01:1;
g = arrayfun(@(x) eigs(A(x),1), p);

Breakdown:

• Define A as an anonymous function. This means that the command A(x) will return your matrix A with the (3,3) element equal to x.
• Define all steps you want to take in vector p
• Then “loop” through all elements in p by using arrayfun instead of an actual loop.

The function looped over by arrayfun is not max(eig(A)) but eigs(A,1), i.e., the 1 largest eigenvalue. The result will be the same, but the algorithm used by eigs is more suited for your type of problem — instead of computing all eigenvalues and then only using the maximum one, you only compute the maximum one. Needless to say, this is much faster.