F# Power 问题，它接受两个参数都是 bigints

Question

我目前正在尝试使用 F#。在 Internet 上找到的文章很有帮助，但作为 C# 程序员，我有时会遇到一些情况，我认为我的解决方案会有所帮助，但它没有或只是部分帮助。

所以我对 F# 的了解（很可能是编译器的工作原理）可能是我有时完全惊呆的原因。

例如，我编写了一个 C# 程序来确定完美数。它使用已知形式的欧几里得证明，完美数可以由梅森素数 2p-1(2p-1) 形成（其中 2p-1 是素数，p 表示为的幂）。

由于 F# 的帮助表明 '**' 可用于计算幂，但使用浮点数，因此我尝试使用位移运算符 (

 let PowBitShift (y:int32) = 1 <<< y;;

但是，在运行测试并寻求性能改进时，我还尝试了一种我记得使用 Miranda（也是一种函数式编程语言）的形式，它使用递归和模式匹配器来计算功率。主要好处是我可以将变量 y 用作 64 位整数，这是标准位移运算符无法实现的。

    let rec Pow (x : int64) (y : int64) = 
    match y with
        | 0L -> 1L
        | y -> x * Pow x (y - 1L);;

事实证明，这个函数实际上更快，但我（还）不明白其中的原因。也许这是一个不那么理智的问题，但我仍然很好奇。

那么第二个问题是，在计算完美数时，您会遇到这样一个事实，即 int64 无法显示在找到第 9 个完美数（由 31 的幂形成）后交叉的大数。我试图找出你是否可以使用 BigInteger 对象（或 bigint 类型），但在这里我对 F# 的了解有点阻碍我。是否可以创建一个同时接受两个参数为 bigint 的 powerfunction？

我目前有这个：

let rec PowBigInt (x : bigint) (y : bigint) = 
    match y with
        | bigint.Zero -> 1I
        | y -> x * Pow x (y - 1I);;

但它会抛出一个错误，即 bigint.Zero 未定义。所以我在那里也做错了什么。 0I 不被接受作为替代品，因为它给出了这个错误：

Non-primitive numeric literal constants cannot be used in pattern matches because they    
can be mapped to multiple different types through the use of a NumericLiteral module.  
Consider using replacing with a variable, and use 'when <variable> = <constant>' at the 
end of the match clause.    

但是模式匹配器不能使用'when'语句。有其他解决方案吗？

先谢谢了，请原谅我的长帖。我只是想尽可能清楚地表达我的“挑战”。

Answer 1

我不明白为什么你需要 y 成为 int64 或 bigint。根据this link，已知最大的梅森数是p = 43112609，其中p确实在int的范围内。

将y 用作整数，您可以改用标准运算符pown : ^T -> int -> ^T，因为：

let Pow (x : int64) y = pown x y
let PowBigInt (x: bigint) y = pown x y

关于你的模式匹配bigint的问题，错误信息非常清楚地表明你可以通过when守卫使用模式匹配：

let rec PowBigInt x y = 
    match y with
    | _ when y = 0I -> 1I
    | _ -> x * PowBigInt x (y - 1I)

Answer 2

我认为定义PowBigInt 的最简单方法是使用if 而不是模式匹配：

let rec PowBigInt (x : bigint) (y : bigint) =  
  if y = 0I then 1I   
  else x * PowBigInt x (y - 1I) 

问题在于bigint.Zero 是一个返回值的静态属性，但模式只能包含（常量）文字或 F# 活动模式。它们不能直接包含属性（或其他）调用。但是，如果您仍然喜欢match，您可以在where 子句中编写额外的约束：

let rec PowBigInt (x : bigint) (y : bigint) =  
  match y with 
  | y when y = bigint.Zero -> 1I 
  | y -> x * PowBigInt x (y - 1I)

作为旁注，您可能可以使用 tail-recursion 使函数更有效（这个想法是，如果一个函数将递归调用作为最后一件事，那么它可以被编译得更多有效）：

let PowBigInt (x : bigint) (y : bigint) =   
  // Recursive helper function that stores the result calculated so far
  // in 'acc' and recursively loops until 'y = 0I'
  let rec PowBigIntHelper (y : bigint) (acc : bigint) =
    if y = 0I then acc 
    else PowBigIntHelper (y - 1I) (x * acc)
  // Start with the given value of 'y' and '1I' as the result so far
  PowBigIntHelper y 1I

关于 PowBitShift 函数 - 我不确定它为什么会变慢，但它绝对不能满足您的需求。只有当基数为 2 时，才使用位移来实现幂。

Answer 3

您不需要创建 Pow 函数。 (**) 运算符对 bigint -> int -> bigint 有重载。 只有第二个参数应该是一个整数，但我认为这对你的情况来说不是问题。 试试看

大整数 10 ** 32 ;;

val it : System.Numerics.BigInteger =
  100000000000000000000000000000000 {IsEven = true;
                                     IsOne = false;
                                     IsPowerOfTwo = false;
                                     IsZero = false;
                                     Sign = 1;}

Answer 4

另一种选择是内联您的函数，使其适用于所有数字类型（支持所需的运算符：(*)、(-)、get_One 和 get_Zero）。

let rec inline PowBigInt (x:^a) (y:^a) : ^a =  
  let zero = LanguagePrimitives.GenericZero 
  let one = LanguagePrimitives.GenericOne
  if y = zero then one
  else x * PowBigInt x (y - one) 

let x = PowBigInt 10 32     //int
let y = PowBigInt 10I 32I   //bigint
let z = PowBigInt 10.0 32.0 //float

我可能会建议按照 Tomas 的建议将其设为尾递归。