Ruby以编程方式生成lambda

Question

我试图以lambda编程方式生成.这是一个例子:

这是我需要生成的矩阵:

m = [[a(t), b(t)],
     [c(t), d(t)]]

这是一个依赖于时间的矩阵.如果a,b,c,d功能总是我将创建一个这样的拉姆达相同:

m = lambda{|t| [[a(t), b(t)], [c(t), d(t)]]}

并称之为:

m.call(x)

这些功能并不完全通用,但它们只能来自有限的列表.问题是我不知道在执行某些计算之前,从这个列表中可以看出哪些功能.在我的例子中,例如,我只有三个可能的函数,所以lambda可以是:

m = lambda{|t| [[f1(t), f2(t)], [f2(t), f3(t)]]}

要么

m = lambda{|t| [[f3(t), f3(t)], [f1(t), f2(t)]]}

或三种功能的任何其他组合.

有没有办法以lambdas编程方式定义？这是最好的方法吗？

在实际代码中,这个矩阵可能非常大,容易500x10,000(500,000)个元素.它在第一个循环中计算.之后循环遍历t值.对于每个t功能当然不会改变.此外,这些函数是简单的数学表达式,如power,exp等...

Answer 1

您可以将lambdas用作fs的附加参数m:

m = lambda { |t, a, b, c, d| [[a[t], b[t]], [c[t], d[t]]] }

f1 = lambda { |x| x**2 }
f2 = lambda { |x| x**3 }
f3 = lambda { |x| x**4 }

p m[2, f1, f2, f2, f3]  # [[4, 8], [8, 16]]
p m[2, f3, f3, f1, f2]  # [[16, 16], [4, 8]]

根据您的扩​​展问题,这里的方法更具动态性,可以扩展到大型矩阵.我假设您有一些算法来确定算法中哪一点需要哪些lambdas,但是因为我不知道那是什么,所以我使用了tabled规范.

# Dynamically create a 2-d array of lambdas, determined by an
# index set referencing the pool of lambdas, with specified row_length
m = lambda do |f_set, index, row_length|
  Array.new(index.size) { |i| f_set[index[i]] }.each_slice(row_length).to_a
end

# Function to evaluate actual outcomes yielded by applying
# the lambdas in m to argument x.
def evaluate(m, x)
  m.map { |row| row.map { |lmb| lmb[x] } }
end

# Pool of lambdas used to generate m
f_set = [
  lambda { |x| x**2 },
  lambda { |x| x**3 },
  lambda { |x| x**4 }
]

# You'll need some way to specify which lambdas will be used,
# either with table lookup (as below), or preferably via some
# algorithm if the array sizes will be large.
indices = [[0, 1, 1, 2, 0, 1], [2, 2, 0, 1, 0, 1]]

# create different sets of arrays m populated with lambdas as
# specified by indices to the f_set.
m_3x2 = indices.map { |index_set| m[f_set, index_set, 2]}
m_2x3 = indices.map { |index_set| m[f_set, index_set, 3]}

m_3x2.each { |m| p evaluate(m, 2) }
# [[4, 8], [8, 16], [4, 8]]
# [[16, 16], [4, 8], [4, 8]]
m_2x3.each { |m| p evaluate(m, 2) }
# [[4, 8, 8], [16, 4, 8]]
# [[16, 16, 4], [8, 4, 8]]


m_3x2.each { |m| p evaluate(m, 3) }
# [[9, 27], [27, 81], [9, 27]]
# [[81, 81], [9, 27], [9, 27]]
m_2x3.each { |m| p evaluate(m, 3) }
# [[9, 27, 27], [81, 9, 27]]
# [[81, 81, 9], [27, 9, 27]]