memoization

There are a few automatic memoization libraries available on the internet for various different languages; but without knowing what they are for, where to use them, and how they work, it can be difficult to see their value. What are some convincing arguments for using memoization, and what problem domain does memoization especially shine in? Information for the uninformed would be especially appreciated here. The popular factorial answer here is something of a toy answer. Yes, memoization is useful for repeated invocations of that function, but the relationship is trivial — in the "print

Let's take Wes Dyer's approach to function memoization as the starting point: public static Func<A, R> Memoize<A, R>(this Func<A, R> f) { var map = new Dictionary<A, R>(); return a => { R value; if (map.TryGetValue(a, out value)) return value; value = f(a); map.Add(a, value); return value; }; } The problem is, when using it from multiple threads, we can get into trouble: Func<int, int> f = ... var f1 = f.Memoize(); ... in thread 1: var y1 = f1(1); in thread 2: var y2 = f1(1); // We may be recalculating f(1) here! Let's try to avoid this. Locking on map : public static Func<A, R> Memoize<A, R>

I know of this one http://onjava.com/pub/a/onjava/2003/08/20/memoization.html but is there anything else? lacroix1547 Memoization is also easy with plain simple typesafe Java. You can do it from scratch with the following reusable classes. I use these as caches whose lifespan are the request on a webapp. Of course use the Guava MapMaker if you need an eviction strategy or more features like synchronization. If you need to memoize a method with many parameters, just put the parameters in a list with both techniques, and pass that list as the single parameter. abstract public class Memoize0<V> {

In mid July 2008 Memoization was added to Rails core. A demonstration of the usage is here . I have not been able to find any good examples on when methods should be memoized, and the performance implications of each. This blog post , for example, suggests that oftentimes, memoization should not be used at all. For something that could potentially have tremendous performance implications, there seem to be few resources that go beyond providing a simple tutorial. Has anyone seen memoization used in their own projects? What factors would make you consider memoizing a method? After doing some

Ok, here is the real world scenario: I'm writing an application, and I have a class that represents a certain type of files (in my case this is photographs but that detail is irrelevant to the problem). Each instance of the Photograph class should be unique to the photo's filename. The problem is, when a user tells my application to load a file, I need to be able to identify when files are already loaded, and use the existing instance for that filename, rather than create duplicate instances on the same filename. To me this seems like a good situation to use memoization, and there's a lot of