获取拉格朗日插值的多项式表示

Question

我如何表示不完整的数学函数？

我需要做类似(x - constant)

(x - constant)*(x - another) => (x^2 - x * constant - x * another + constant * another)

等等。

我正在尝试制作一个程序来进行拉格朗日插值（在某些点上找到一个函数），因此我需要从一组已知值中创建一个我可以看到的函数（打印出来的东西）。 对不起，如果造成混淆。

Answer 1

如果您要实现此处讨论的拉格朗日插值

得到一个插值的函数：

这就是直接翻译成F＃：

let LagrangeInterpol (points : (Double*Double)[]) x =
    let indizes = [0..points.Length-1]
    let p j = 
        indizes
        |> List.map (fun k -> 
            if k <> j 
            then (x - fst points.[k]) 
                  / (fst points.[j] - fst points.[k]) 
            else 1.0)
        |> List.fold (*) 1.0 
    indizes |> List.sumBy (fun j -> p j * snd points.[j])

例子

这是一个简单的测试会话：

> let points = [|0.0,0.0; 1.0,2.0; 2.0,3.0|];;
val points : (float * float) [] = [|(0.0, 0.0); (1.0, 2.0); (2.0, 3.0)|]

> let f = LagrangeInterpol points;;
val f : (Double -> float)

> f 0.0;;
val it : float = 0.0

> f 1.0;;
val it : float = 2.0

> f 2.0;;
val it : float = 3.0

因此，我希望我没有犯任何重大错误。

请注意，我在这里没有做任何性能优化的工作-这足以绘制图形或在两者之间获得一些值。

得到多项式的表示

这有点棘手-您可以尝试提出系数的组合公式，或者（像我在这里一样）是数学惰性的，并且只需使用足够多的运算符来实现Polynom-Type即可：

type Polynom = 
    Poly of float list with
    override p.ToString () =
        match p with
        | Poly coefs -> 
            System.String.Join (" + ", coefs |> List.mapi (fun i c -> sprintf "%AX^%d" c i))
    static member Const c = Poly [c]
    static member Zero = Polynom.Const 0.0
    static member One = Polynom.Const 1.0
    static member X = Poly [0.0; 1.0]
    static member (+) (Poly cs1, Poly cs2) =
        let m = max (List.length cs1) (List.length cs2)
        List.zip (ofLen m cs1) (ofLen m cs2)
        |> List.map (fun (a,b) -> a+b)
        |> Poly
    static member (-) (Poly cs1, Poly cs2) =
        let m = max (List.length cs1) (List.length cs2)
        List.zip (ofLen m cs1) (ofLen m cs2)
        |> List.map (fun (a,b) -> a-b)
        |> Poly
    static member (*) (f : float, Poly cs2) : Polynom =
        cs2
        |> List.map (fun c -> f * c)
        |> Poly
    static member private shift n (Poly cs) =
        List.replicate n 0.0 @ cs |> Poly
    static member (*) (Poly cs1, p2 : Polynom) : Polynom =
        cs1
        |> List.mapi (fun i c -> Polynom.shift i (c * p2))
        |> List.sum
    static member (/) (Poly cs1, f : float) : Polynom =
        cs1
        |> List.map (fun c -> c / f)
        |> Poly

在这里，我仅使用float的列表表示多项式的系数（因此X^2 + 2X + 3是Poly [3.0; 2.0; 1.0]请注意，第i个系数是X^i处的一个。

有了这个，我们可以使用与以前几乎相同的功能：

let getPolynom (points : (float * float)[]) =
    let indizes = [0..points.Length-1]
    let p j = 
        indizes
        |> List.map (fun k -> 
            if k <> j 
            then (Polynom.X - Polynom.Const (fst points.[k]))
                  / (fst points.[j] - fst points.[k]) 
            else Polynom.One)
        |> List.fold (*) Polynom.One
    indizes |> List.sumBy (fun j -> Polynom.Const (snd points.[j]) * p j)      

如您所见，我使用了相同的函数，仅将参数x替换为Polynom.X并包装了常量approbiatley。

例子

这是两个示例（将它们与Wiki-Page比较，应该是正确的）：

> LagrangeInterpolation.getPolynom 
    [|(1.0, 1.0); (2.0, 4.0); (3.0, 9.0)|] |> string;;
val it : string = "0.0X^0 + 0.0X^1 + 1.0X^2"

> LagrangeInterpolation.getPolynom 
     [| 1.0,1.0; 2.0,8.0; 3.0,27.0 |] |> string;;
val it : string = "6.0X^0 + -11.0X^1 + 6.0X^2"

与助手一起完成代码

在模块内部的完整代码是：

module LagrangeInterpolation =

    let private ofLen n cs =
        let l = List.length cs
        if l < n
            then cs @ List.replicate (n-l) 0.0
            else cs

    type Polynom = 
        Poly of float list with
        override p.ToString () =
            match p with
            | Poly coefs -> 
                System.String.Join (" + ", coefs |> List.mapi (fun i c -> sprintf "%AX^%d" c i))
        static member Const c = Poly [c]
        static member Zero = Polynom.Const 0.0
        static member One = Polynom.Const 1.0
        static member X = Poly [0.0; 1.0]
        static member (+) (Poly cs1, Poly cs2) =
            let m = max (List.length cs1) (List.length cs2)
            List.zip (ofLen m cs1) (ofLen m cs2)
            |> List.map (fun (a,b) -> a+b)
            |> Poly
        static member (-) (Poly cs1, Poly cs2) =
            let m = max (List.length cs1) (List.length cs2)
            List.zip (ofLen m cs1) (ofLen m cs2)
            |> List.map (fun (a,b) -> a-b)
            |> Poly
        static member (*) (f : float, Poly cs2) : Polynom =
            cs2
            |> List.map (fun c -> f * c)
            |> Poly
        static member private shift n (Poly cs) =
            List.replicate n 0.0 @ cs |> Poly
        static member (*) (Poly cs1, p2 : Polynom) : Polynom =
            cs1
            |> List.mapi (fun i c -> Polynom.shift i (c * p2))
            |> List.sum
        static member (/) (Poly cs1, f : float) : Polynom =
            cs1
            |> List.map (fun c -> c / f)
            |> Poly

    let getPolynom (points : (float * float)[]) =
        let indizes = [0..points.Length-1]
        let p j = 
            indizes
            |> List.map (fun k -> 
                if k <> j 
                then (Polynom.X - Polynom.Const (fst points.[k]))
                      / (fst points.[j] - fst points.[k]) 
                else Polynom.One)
            |> List.fold (*) Polynom.One
        indizes |> List.sumBy (fun j -> Polynom.Const (snd points.[j]) * p j)      

备注

为了获得更好的输出，您可能应该添加一些简化（例如Poly [1.0;0.0] -> Poly [1.0] ）并改进ToString方法，但我确定您可以处理;）

Answer 2

如果您指的是partial函数，即在某些输入中未定义函数，那么通常有两种方法可以处理此问题。 一种选择是使用option<'T>类型并将正确的结果包装在Some或者在未定义值时返回None 。 例如：

let safeDivide a b =
    if b = 0 then None else Some(a / b)

调用者必须对结果进行模式匹配（或使用类似Maybe计算生成器之类的方法 ），这使得调用函数更加困难，但是您可以完全控制错误的处理方式。

另一个选择是引发异常。 对于整数除法，这会自动发生，但是您可以编写如下内容：

let safeDivide a b =
    if b = 0 then invalidArg "b" "Division by zero!"
    a / b

编写起来有点容易，但是您需要了解其行为并正确处理异常。