F#向量运算的类型约束

Question

我想用F#编写一些通用函数和类型来处理向量。我有多个不同的数据类型，带有静态(+)和(*)运算符，所以我可以将它们相加并乘以标量(目前为float(。

例如，我成功地构建了一个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>可以存储采用intx并返回两个分量都等于float x的Vec2的函数。也许我们可以通过调用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 

这种类型进行检查，但我不确定它是否做了正确的事情(我不确定向量函数的加法和乘法应该做什么！(-但在任何情况下，它都可能帮助你找到正确的方向。