向量运算的 F# 类型约束

Question

我想在 F# 中编写一些通用函数和类型来处理向量。我有多种不同的数据类型，带有静态 (+) 和 (*) 运算符，因此我可以将它们相加并乘以标量（现在为 floats）。

例如，我已经成功构建了一个 Vec2 类，我可以在其中编写代码

let v = 3.0 * Vec2(1.,1.) + Vec2(3.,4.)

假设我还有一个Vec3 或任何其他类型的向量。这是我想写的两个示例（伪代码）：

向量的通用函数

我认为这可以通过断言'V 具有(+) 和(*) 的静态解析类型约束来实现，但我无法让它工作。如果我可以将我的类型约束命名如下，那就太好了。

let average<'V when 'V : vector> (v1:'V) (v2:'V) =
    0.5 * (v1 + v2)

有没有实际可行的替代方案？

本身就是向量类型的泛型类型

对于任何类型的'T 和表示向量的类型'V，我们可以像向量一样添加和标量乘法函数'T -> 'V。我想建立一个像

type VecFunc<'T,'V when 'V : vector> = ...

作为一个简单的示例，f : VecFunc<int,Vec2> 可以存储一个函数，该函数采用 int x 并返回一个 Vec2，两个组件都等于 float x。也许我们可以通过调用Eval 方法来评估底层函数：

f.Eval(3) // would return Vec2(3.,3.)

我想将 VecFunc<int,Vec2> 视为向量类型，给它 (+) 和 (*) 操作，以便我可以计算

(-2.0 * f + f).Eval(2) // returns Vec2(-4., -4.)

或结合第一个例子：

(average f g).Eval(1) // ...

有没有什么方法可以使用 F# 接口或者类型参数来实现这些结果？

Answer 1

您可以通过要求您的向量类型（以及向量上的函数）实现某些运算符来执行这些操作。根据您的示例，我想您已经有+ 用于Vec2 和* 用于将向量乘以标量。您可以根据这些运算符编写 average 函数，然后它将适用于具有这些运算符的任何类型。

唯一的问题是 F# 以某种特殊的方式处理 *，因此如果您有类型为 float * vector -> vector 的 *，您将无法轻松做到这一点。如果您使用.* 进行标量乘向量乘法，它似乎工作正常（同样，您可以添加*. 用于另一个方向）。

这是我对Vec2 和Vec3 的定义：

type Vec2(a:float, b:float) = 
  member x.A = a
  member x.B = b
  static member (.*) (a:float, v:Vec2) = 
    Vec2(a*v.A, a*v.B)
  static member (+) (v1:Vec2, v2:Vec2) = 
    Vec2(v1.A+v2.A, v1.B+v2.B)

type Vec3(a:float, b:float, c:float) = 
  member x.A = a
  member x.B = b
  member x.C = c
  static member (.*) (a:float, v:Vec3) = 
    Vec3(a*v.A, a*v.B, a*v.C)
  static member (+) (v1:Vec3, v2:Vec3) = 
    Vec3(v1.A+v2.A, v1.B+v2.B, v1.C+v2.C)

现在您可以将average 编写为使用静态成员约束的内联函数：

let inline average (v1:^V) (v2:^V) =
  (^V : (static member (.*) : float * ^V -> ^V) (0.5, v1 + v2))

average (Vec2(1.,1.)) (Vec2(3.,4.))
average (Vec3(1.,1.,1.)) (Vec3(3.,4.,5.))

如果你使用+ 操作符，F# 会自动添加一个约束，所以我可以写v1 + v2。 .* 运算符是非标准的，因此我必须显式调用它。

对于您问题的第二部分 - 正如您所指出的，F# 类型不能由具有静态类型约束的其他类型参数化，因此这样做需要更多技巧。您拥有的一种选择是将您需要的操作添加为类型的参数，然后使用inline 函数捕获操作并将它们作为常规函数传递给您的VecFunc 类型。这是一个例子：

type VecFunc<'T1, 'T2>(f:'T1 -> 'T2, mult:float * 'T1 -> 'T1, add:'T2 * 'T2 -> 'T2) = 
  member x.F = f
  member x.Mult = mult
  member x.Add = add
  static member (.*) (a:float, f:VecFunc<_, _>) = 
    VecFunc((fun v -> f.F (f.Mult(a, v))), f.Mult, f.Add)
  static member (+) (f1:VecFunc<_, _>, f2:VecFunc<_, _>) = 
    VecFunc((fun v -> f1.Add(f1.F v, f2.F v)), f1.Mult, f1.Add)

let inline vfunc (f:^V -> ^T) = 
    VecFunc< ^V, ^T>(f, 
      (fun (a, b) -> (^V : (static member (.*) : float * ^V -> ^V) (a, b))),
      (fun (a, b) -> a + b))

let vf = vfunc (fun (v:Vec2) -> v + v)
average vf vf 

此类型检查，但我不确定它是否正确（我不确定向量函数的加法和乘法应该做什么！） - 但无论如何，它可能会帮助您找到正确的方向。