Mdthbs

Consider the following method commonly used to clear a typical variable:

In[117]:= data = {1, 2, 3}



Out[117]= {1, 2, 3}



In[118]:= ByteCount[data]



Out[118]= 112



In[119]:= Clear[data]



In[120]:= ByteCount[data]



Out[120]= 0

No problem. Now, if I store the same information in an indexed variable, problems arise.

In[121]:= mytest[data] = {1, 2, 3}



Out[121]= {1, 2, 3}



In[122]:= ByteCount[mytest[data]]



Out[122]= 112



In[123]:= Clear[mytest[data]]



During evaluation of In[123]:= Clear::ssym: mytest[data] is not a symbol or a string.



In[124]:= ByteCount[mytest[data]]



Out[124]= 112

Is there a way to clear the values of indexed values so they don't consume memory?

My primary application requires large volumes of data to be stored in indexed variables, and at appropriate times, I would like to be able to "erase" that data from memory as my datasets are really big (multiple GBs per file).

Following initial comments, I realized I needed to re-word my initial question. (which I've done.) Taking advice from the comments, it seems Unset may be the way to go here.

Notice:

In[23]:= mytest[data] = {1, 2, 3}



Out[23]= {1, 2, 3}



In[24]:= mytest[data2] = {4, 5, 6, 7}



Out[24]= {4, 5, 6, 7}



In[6]:= ByteCount[mytest[data]]



Out[6]= 112



In[19]:= ByteCount[mytest[data2]]



Out[19]= 136



In[25]:= mytest[data] =.



In[26]:= ByteCount[mytest[data]]



Out[26]= 48



In[27]:= mytest[data]



Out[27]= mytest[data]



In[28]:= mytest[data2]



Out[28]= {4, 5, 6, 7}

As an add on, why is there a small amount of memory still attached to mytest[data] after performing the Unset operation?

Byte count is 64, for entry in indexed variable. Even if there is no data

As mentioned in comment, use =. to clear specific index

Too long for a comment:

ByteCount[mytest[data]] measures the memory required for the expression mytest[data]. The ByteCount of a Symbol is always zero; see the docs for ByteCount:

Symbols are effectively always shared, so they give 0 byte count:

In other words (I think), it does not count the memory required to store the symbol in the symbol/hash table.

The OP's first ByteCount[data] computes ByteCount[{1, 2, 3}] because data evaluates to the expression {1, 2, 3} before ByteCount is called. Consider

Trace[ByteCount@data]

(*  {{data, {1, 2, 3}},

     ByteCount[{1,2,3}],

     112}  *)

Also consider the difference between the evaluated and unevaluated data:

data = {1, 2, 3}; 

ByteCount /@ {data, Unevaluated@data}

(*  {112, 0}  *)

@Nasser's example ByteCount[a[1]] gives 64 bytes and the OP's ByteCount[mytest[data]] gives 48 bytes (after data is cleared). Here is an accounting of it:

Clear[a, b];

ByteCount@ 1

ByteCount@ a[b]

ByteCount@ a[1]

(*

  16  - storage of one integer

  48  - storage of the head--argument tree expression

  64  - total

*)

One can carry this accounting game further. For instance, ByteCount@ 2[1]
gives 80. However, beware that according to the docs,

ByteCount will...often give an overestimate of the amount of memory...needed....

Back to the principal question, which has already been answered, how to free up memory when a value is no longer needed:

• 
  Unset will remove a single value (definition).


• 
  Clear will remove all values (definitions) but not attributes, options, defaults or messages.


• 
  ClearAll will remove all values, attributes, options, defaults and messages.


• 
  Remove removes the symbol (thereby all things associated with it) from the symbol table.

See the docs for more information. As has been noted in the comments and @Nasser's answer, Unset is the desired solution in the OP's case.