A compact one returning a lambda: template <typename R, typename… Args> std::function<R (Args…)> memo(R (*fn)(Args…)) { std::map<std::tuple<Args…>, R> table; return [fn, table](Args… args) mutable -> R { auto argt = std::make_tuple(args…); auto memoized = table.find(argt); if(memoized == table.end()) { auto result = fn(args…); table[argt] = result; return result; } else { return memoized->second; } }; … Read more
Consider calculating the fibonacci sequence: Pure recursion: int fib(int x) { if (x < 2) return 1; return fib(x-1) + fib(x-2); } results in exponential number of calls. Recursion with memoization/DP: int fib(int x) { static vector<int> cache(N, -1); int& result = cache[x]; if (result == -1) { if (x < 2) result = 1; … Read more
Is there any specific reason as why it is not available in 2.7? @Nirk has already provided the reason: unfortunately, the 2.x line only receive bugfixes, and new features are developed for 3.x only. Is there any 3rd party library providing the same feature? repoze.lru is a LRU cache implementation for Python 2.6, Python 2.7 … Read more
I did not have luck with memoise because it gave a ‘too deep recursive’ problem to some functions of a package I tried it with. With R.cache I had better luck. Following is more annotated code I adapted from the R.cache documentation. The code shows different options for doing caching: # Workaround to avoid question … Read more
GHC does not memoize functions. It does, however, compute any given expression in the code at most once per time that its surrounding lambda-expression is entered, or at most once ever if it is at top level. Determining where the lambda-expressions are can be a little tricky when you use syntactic sugar like in your … Read more
The evaluation mechanism in Haskell is by-need: when a value is needed, it is calculated, and kept ready in case it is asked for again. If we define some list, xs=[0..] and later ask for its 100th element, xs!!99, the 100th slot in the list gets “fleshed out”, holding the number 99 now, ready for … Read more
3.8 ≤ Python @property and @functools.lru_cache have been combined into @cached_property. import functools class MyClass: @functools.cached_property def foo(self): print(“long calculation here”) return 21 * 2 3.2 ≤ Python < 3.8 You should use both @property and @functools.lru_cache decorators: import functools class MyClass: @property @functools.lru_cache() def foo(self): print(“long calculation here”) return 21 * 2 This answer … Read more
We can do this very efficiently by making a structure that we can index in sub-linear time. But first, {-# LANGUAGE BangPatterns #-} import Data.Function (fix) Let’s define f, but make it use ‘open recursion’ rather than call itself directly. f :: (Int -> Int) -> Int -> Int f mf 0 = 0 f … Read more
Memoization is a specific form of caching that involves caching the return value of a function based on its parameters. Caching is a more general term; for example, HTTP caching is caching but not memoization. Wikipedia says: Although related to caching, memoization refers to a specific case of this optimization, distinguishing it from forms of … Read more
Starting from Python 3.2 there is a built-in decorator: @functools.lru_cache(maxsize=100, typed=False) Decorator to wrap a function with a memoizing callable that saves up to the maxsize most recent calls. It can save time when an expensive or I/O bound function is periodically called with the same arguments. Example of an LRU cache for computing Fibonacci … Read more