所以在Rails 3.2中,不推荐使用ActiveSupport :: Memoizable.
消息如下:
DEPRECATION WARNING: ActiveSupport::Memoizable is deprecated and
will be removed in future releases,simply use Ruby memoization
pattern instead.
它指的是"Ruby memoization pattern"(单数),好像有一个模式,我们都应该知道并参考...
我认为他们的意思是:
def my_method
@my_method ||= # ... go get the value
end
要么
def my_method
return @my_method if defined?(@my_method)
@my_method = # ... go get the value
end
还有其他我错过的东西吗？
寻找一种方法来实现一个通用的通用memoization函数,它将获取一个函数并返回相同的memoized版本？
在python中寻找像@memo(来自Norving的网站)装饰的东西.
def memo(f):
table = {}
def fmemo(*args):
if args not in table:
table[args] = f(*args)
return table[args]
fmemo.memo = table
return fmemo
更一般的是,有没有办法在C++中表达泛型和可重用的装饰器,可能使用C++ 11的新功能？
我想记住这个:
def fib(n: Int) = if(n <= 1) 1 else fib(n-1) + fib(n-2)
println(fib(100)) // times out
所以我写了这个,这令人惊讶地编译和工作(我很惊讶,因为fib在其声明中引用自己):
case class Memo[A,B](f: A => B) extends (A => B) {
private val cache = mutable.Map.empty[A, B]
def apply(x: A) = cache getOrElseUpdate (x, f(x))
}
val fib: Memo[Int, BigInt] = Memo {
case 0 => 0
case 1 => 1
case n => fib(n-1) + fib(n-2)
}
println(fib(100)) // prints 100th fibonacci number instantly
但是当我尝试在a中声明fib时def,我得到一个编译器错误:
def foo(n: …scope scala memoization dynamic-programming forward-reference
我在python中编写一个类,我有一个属性需要相对长的时间来计算,所以我只想做一次.此外,它会不会被类的每个实例需要的,所以我不想在默认情况下做到这一点在__init__.
我是Python新手,但不是编程.我可以很容易地找到一种方法来做到这一点,但我一次又一次地发现,使用我在其他语言中的经验,"Pythonic"做事的方式通常比我想象的要简单得多.
在Python中有没有"正确"的方法呢？
可能重复:
动态编程和记忆:自上而下与自下而上的方法
我已经阅读了很多文章,但似乎无法理解它.有时递归和动态编程看起来相同,而在其他时候,memoization和动态编程看起来很相似.有人可以向我解释有什么区别吗？
PS如果您可以使用针对同一问题的三种方法向我指出一些代码,那么它也会很有帮助.(例如Fibonacci系列问题,我认为我读过的每篇文章都使用了递归,但将其称为动态编程)
我一直在寻找Data.MemoCombinators的来源,但我无法真正看到它的核心位置.
请向我解释所有这些组合器背后的逻辑以及它们如何在实际编程中加速您的程序实际工作的机制.
我正在寻找这个实现的细节,并可选择与其他Haskell方法进行比较/对比来进行memoization.我理解什么是memoization,而不是在寻找它的工作原理.
我正在尝试编写一个在Clojure中返回memoized递归函数的函数,但是我在使递归函数看到它自己的memoized绑定时遇到了麻烦.这是因为没有创建var吗？另外,为什么我不能在用let创建的本地绑定上使用memoize？
这个稍微不同寻常的Fibonacci序列制作者从一个特定的数字开始就是我希望我能做的一个例子:
(defn make-fibo [y]
(memoize (fn fib [x] (if (< x 2)
y
(+ (fib (- x 1))
(fib (- x 2)))))))
(let [f (make-fibo 1)]
(f 35)) ;; SLOW, not actually memoized
使用with-local-vars似乎是正确的方法,但它对我也不起作用.我想我不能关闭vars？
(defn make-fibo [y]
(with-local-vars [fib (fn [x] (if (< x 2)
y
(+ (@fib (- x 1))
(@fib (- x 2)))))]
(memoize fib)))
(let [f (make-fibo 1)]
(f 35)) ;; Var null/null is unbound!?!
我当然可以手动编写一个宏来创建一个封闭的原子并自己管理memoization,但我希望没有这样的hackery这样做.
我正在尝试为具有任意数量参数的函数创建一个memoization接口,但我失败了,我觉得我的解决方案不是很灵活.我试图为一个函数定义一个接口,该接口在执行时自动被记忆,每个函数都必须实现这个接口.以下是具有两个参数指数移动平均值函数的示例:
class EMAFunction:IFunction
{
Dictionary<List<object>, List<object>> map;
class EMAComparer : IEqualityComparer<List<object>>
{
private int _multiplier = 97;
public bool Equals(List<object> a, List<object> b)
{
List<object> aVals = (List<object>)a[0];
int aPeriod = (int)a[1];
List<object> bVals = (List<object>)b[0];
int bPeriod = (int)b[1];
return (aVals.Count == bVals.Count) && (aPeriod == bPeriod);
}
public int GetHashCode(List<object> obj)
{
// Don't compute hash code on null object.
if (obj == null)
{
return 0;
}
List<object> vals = (List<object>) obj[0];
int period = …我想知道...为什么我所知道的任何语言本身都没有提供备忘录作为语言功能？
编辑:澄清一下,我的意思是该语言提供了一个关键字来指定一个给定的函数为memoizable,而不是每个函数都被"默认"自动记忆,除非另有说明.例如,fortran提供关键字PURE以指定特定的功能.我想编译器可以利用这些信息来记忆调用,但是如果你声明PURE是一个带副作用的函数,我会忽略会发生什么.
有可能以某种方式结合memoization和tail-recursion吗？我现在正在学习F#并理解这两个概念,但似乎无法将它们结合起来.
假设我有以下memoize功能(来自Real-World Functional Programming):
let memoize f = let cache = new Dictionary<_, _>()
(fun x -> match cache.TryGetValue(x) with
| true, y -> y
| _ -> let v = f(x)
cache.Add(x, v)
v)
以及以下factorial功能:
let rec factorial(x) = if (x = 0) then 1 else x * factorial(x - 1)
记忆factorial并不太难,并且使尾递归也不是:
let rec memoizedFactorial =
memoize (fun x -> if (x = 0) then 1 else x * memoizedFactorial(x - …