A word for storing pre calculated-constructed data

Question

I precalculate data and store it in a static table and call this process 'caching' but that doesn't seem correct based on a quick dictionary search (hiding, concealing) I'm just saving the data statically to avoid the process time to make the calculation. Is there a more appropriate term/word?

I think the key words here are 'static' and 'calculated'

Probable Answers:

As a noun

(the actual output from such a process): Lookup Table

As a verb

(the process of getting there): Tabling

Answer 1

While "caching" traditionally meant "hiding" something, this term has a special meaning when dealing with computer science.

What you are doing would be considered to be in-memory caching, and while "Memoization" is a more accurate term, it is not commonly used in the programming community at large. Programmers are more likely to know what you mean if you describe the action as "caching."

That said:

• The action of "caching" simply means that you are putting data into a place where you can quickly retrieve it later. If this is all your method does, then by all means call it CacheSuchAndSuchData.
• On the other hand, if your method is responsible for producing the data in question (either by invoking another method to build it or by retrieving it from the cache), I'd call it GetSuchAndSuchData.
• If it's responsible for building the data, I'd call it BuildSuchAndSuchData, or CalculateSuchAndSuchData.
• If your method is responsible for doing two or more of the above, you probably need to separate concerns better.

Answer 2

This process is called "Memoization"

http://en.wikipedia.org/wiki/Memoization

Noun: Memoizer
Verb: Memoize

About a year ago I created a generic Memoizer for myself.
(note: this implementation is not thread-safe)

    public class Memoizer<K, V>
    {
      private Dictionary<K, V> _memoized = new Dictionary<K, V>();
      private Func<K, V> _func;
      public Memoizer(Func<K, V> func)
      {
        _func = func;
      }

      public V GetValue(K key)
      {
        V value;
        if (_memoized.TryGetValue(key, out value))
        {
          return value;
        }
        else
        {
          value = _func(key);
          _memoized.Add(key, value);
          return value;
        }
      }
    }

It allows you to call GetValue(key) and it will either retrieve the memoized value or call your lambda (that you specify in the ctor) to calculate (and store) the value.

See https://gist.github.com/abe22dd74b4367b42fd6 for an example of using this for fibinocci.

Answer 3

A stored, pre-calculated table of data is normally called a lookup table or lookup data.

Answer 4

maybe my question would be better phrased as 'what is the 'verb' for the 'process' of storing this data. - Chris

In most Database systems ( esp RDBMS ) this is called Materializing, as in Materializing a View.

This term is the most technically relevant because it implies taking some dynamic data and calculates different data and storing it in some static location.

The actual Source and Destination are irrelevant in the abstract.