Hidden memory?

In the course of coding I came across the following curious example:

classdef lu_apply
    properties
        f;
    end

      methods
          function obj=lu_apply(A)
              [L,U]=lu(A);
              obj.f=@(X) U\(L\X);
          end
      end
  end

The following test run is confusing me:

>> A=rand(100); x=rand(100,1); foo=lu_apply(A);
>> whos
  Name        Size             Bytes  Class       Attributes

    A         100x100            80000  double                
    foo         1x1                136  lu_apply              
    x         100x1                800  double                

>> norm(foo.f(x)-A\x)

ans =

       0

What's bothering me is that it would seem as though the L and U have to be stored somewhere, but it's not at all clear to me where that is. The only other possibility would be to compute the L and U at each call, but the LU routine is only called when the class is constructed. My questions are... where are the L and U located, if anywhere? And if they are somewhere, when is the memory freed? Also, is there anyway to remedy this, should I ever want to free the memory manually (first thing that comes to mind is to declare L and U to be global)?

Answer 1

[James Tursa]

To add to what Daniel has already written, consider these lines:

          function obj=lu_apply(A)
              [L,U]=lu(A);
              obj.f=@(X) U\(L\X);
          end

The L and U matrices get created inside the function lu_apply. They are local to the function and will get destroyed once the function returns. The following line:

              obj.f=@(X) U\(L\X);

creates a function handle using the local L and U variables as part of the function definition. At that time, shared data copies of L and U are created and become embedded in the data area of the function handle ... i.e., they essentially become part of the function handle variable itself. Basically these shared data copies of L and U become snapshots of the current state of L and U at the time of the function handle creation and will remain as constants as far as the function handle is concerned.

Whatever happens to L and U downstream doesn't affect this function handle anymore. In particular, when the function returns, the local variables L and U are destroyed, but the shared data copies of them that were created earlier still live on (and use memory) as part of the function handle. The only way to clear this memory is to clear the function handle itself. I don't know of any way to directly interrogate a function handle to determine the sizes of the embedded variables it contains, since I am not familiar with how function handle definitions are encoded in the data area of the variable.

Answer 2

[Daniel Shub]

The whos function tells you about the variables in the current workspace. The variables L ad U exist, but not in any workspace that you can get to. The memory that L and U consume will be cleared when the last reference to them is cleared. In this case there is a hidden reference to L and U in the function handle.

I believe that if you chose to use an environment like MATLAB, you need to be willing to give up control of memory management.