Ruby 以编程方式生成 lambda

Question

我正在尝试以编程方式生成lambda。这是一个例子：

这是我需要生成的矩阵：

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

这是一个时间相关矩阵。如果a、b、c、d 函数始终相同，我将创建一个像这样的 lambda：

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，功能当然不会改变。 此外，这些函数是简单的数学表达式，如幂、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]]

---

根据您的扩​​展问题，这是一种更具动态性的方法 并且可以扩展到大型矩阵。我假设你有一些算法 确定算法中哪一点需要哪些 lambda 的方法，但由于我不知道那是什么，所以我使用了表格规范。

# 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]]