This library is a straightforward combinatorization of the well-known technique of memoization. Let’s start with the canonical example: fib = (map fib’ [0..] !!) where fib’ 0 = 0 fib’ 1 = 1 fib’ n = fib (n-1) + fib (n-2) I interpret what you said to mean that you know how and why this … Read more
Yes, that will suffice. Promises are simple return values, which is their great benefit – in contrast to callbacks, where memoisation code would be horrible. You only might want to make sure that the memoized promise is uncancellable, if your promise library does support some kind of cancellation. Also notice that this form of memoisation … 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
I found a better way to memoize using Scala: def memoize[I, O](f: I => O): I => O = new mutable.HashMap[I, O]() { override def apply(key: I) = getOrElseUpdate(key, f(key)) } Now you can write fibonacci as follows: lazy val fib: Int => BigInt = memoize { case 0 => 0 case 1 => 1 … Read more
Here is the example in Alex Martelli Python Cookbook that show how to create a memoize decorator using cPickle for function that take mutable argument (original version) : import cPickle class MemoizeMutable: def __init__(self, fn): self.fn = fn self.memo = {} def __call__(self, *args, **kwds): import cPickle str = cPickle.dumps(args, 1)+cPickle.dumps(kwds, 1) if not self.memo.has_key(str): … Read more
These functions already exist in scipy. The sigmoid function is available as scipy.special.expit. In [36]: from scipy.special import expit Compare expit to the vectorized sigmoid function: In [38]: x = np.linspace(-6, 6, 1001) In [39]: %timeit y = sigmoid(x) 100 loops, best of 3: 2.4 ms per loop In [40]: %timeit y = expit(x) 10000 … Read more
You could use a mutable.Map[TupleN[A1, A2, …, AN], R] , or if memory is a concern, a WeakHashMap[1]. The definitions below (built on the memoization code from michid’s blog) allow you to easily memoize functions with multiple arguments. For example: import Memoize._ def reallySlowFn(i: Int, s: String): Int = { Thread.sleep(3000) i + s.length } … 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
This is called interning, and yes, Python does do this to some extent, for shorter strings created as string literals. See About the changing id of an immutable string for some discussion. Interning is runtime dependent, there is no standard for it. Interning is always a trade-off between memory use and the cost of checking … 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