【Swift】拉格朗日插值法

最新推荐文章于 2022-07-04 19:39:17 发布
最新推荐文章于 2022-07-04 19:39:17 发布
阅读量434 收藏 1
点赞数
分类专栏： 数学 代码练习 文章标签： swift lagrange
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21841245/article/details/80337834
版权

这大概是我继Java、JavaScript、C++以后第四次写多项式计算再见

先定义term

struct term {
    var coe: Double
    var exp: Double
    init(coe: Double, exp: Double) {
        self.coe = coe;
        self.exp = exp;
    }
}

用一个数组 [term] 表示一个多项式

现在来重载 + 和 * 运算符

func + (a:[term], b:[term]) -> [term] {
    var res = a
    for i in 0..<b.count {
        var flag:Bool = true
        for j in 0..<res.count {
            if b[i].exp == res[j].exp {
                res[j].coe += b[i].coe
                flag = false
            }
        }
        if flag {
            res.append(term(coe:b[i].coe, exp:b[i].exp))
        }
    }
    res.sort() { $0.exp > $1.exp }
    return res
}

func * (a:[term], b:[term]) -> [term] {
    var res:[term] = []
    for i in 0..<a.count {
        for j in 0..<b.count {
            let new_coe:Double = a[i].coe * b[j].coe 
            let new_exp:Double = a[i].exp + b[j].exp
            var flag:Bool = true
            for k in 0..<res.count {
                if res[k].exp == new_exp {
                    res[k].coe += new_coe
                    flag = false
                }
            }
            if flag {
                res.append(term(coe:new_coe, exp:new_exp))
            }
        }
    }
    res.sort() { $0.exp > $1.exp }
    return res
}

然后写求值

func evaluated(poly:[term], x:Double) -> Double {
    var res = 0.0
    for i in 0..<poly.count {
        let coe = poly[i].coe
        let exp = poly[i].exp
        let tmp = coe * pow(x, exp)
        res += tmp
    }
    return res
}

打印函数

func print_poly(res: [term]) {
    for i in 0..<res.count {
        let coe = (i == 0) ? String(format: "%.10e", res[i].coe) : String(format: "%.10e", abs(res[i].coe))
        let exp = Int(res[i].exp)
        switch exp {
            case 0: print("\(coe)", terminator: "")
            case 1: print("\(coe) x", terminator: "")
            default: print("\(coe) x^\(exp)", terminator: "")
        }
        if i == res.count - 1 {
            break;
        }
        if res[i + 1].coe >= 0.0 {
            print(" + ",  terminator: "")
        } else {
            print(" - ", terminator:"")
        }
    }
    print("")
}

现在可以来写拉格朗日插值了（第一个是求多项式，第二个是求值）

func lagran(X:[Double], Y:[Double]) -> [term] {
    var res:[term] = []
    for i in 0..<X.count {
        var tmp:[term] = [term(coe:Y[i], exp:0)]
        for j in 0..<X.count {
            if i != j {
                let poly:[term] = [term(coe:1, exp:1), term(coe:X[j], exp:0)]
                tmp = tmp * poly
                for k in 0..<tmp.count {
                    tmp[k].coe /= (X[i] - X[j])
                }
            }
        }
        res = res + tmp
    }
    return res
}

func lagrange(X: [Double], Y: [Double], x: Double) -> Double {
    var result = 0.0
    for i in 0..<X.count {
        var temp = Y[i]
        for j in 0..<X.count {
            if i != j {
                temp *= (x - X[j])
                temp /= (X[i] - X[j])
            }
        }
        result += temp
    }
    return result
}

然后简单求一下误差

func deviation(min:Double, max:Double, points:Int, lag:[term]) -> Double {
    let increments = (max - min) / Double(points - 1)
    var _x:[Double] = []
    var res1:[Double] = []
    for i in 0..<points {
        let tmpx = min + Double(i) * increments
        _x.append(tmpx)
        res1.append(evaluated(poly:lag, x:tmpx))
    }
    let res2 = function(X:_x)
    var delta:Double = 0;
    for i in 0..<points {
        delta += abs(res1[i] - res2[i])
    }
    delta /= Double(points)
    return delta
}

完整代码：

import Foundation

struct term {
    var coe: Double
    var exp: Double
    init(coe: Double, exp: Double) {
        self.coe = coe;
        self.exp = exp;
    }
}

func + (a:[term], b:[term]) -> [term] {
    var res = a
    for i in 0..<b.count {
        var flag:Bool = true
        for j in 0..<res.count {
            if b[i].exp == res[j].exp {
                res[j].coe += b[i].coe
                flag = false
            }
        }
        if flag {
            res.append(term(coe:b[i].coe, exp:b[i].exp))
        }
    }
    res.sort() { $0.exp > $1.exp }
    return res
}

func * (a:[term], b:[term]) -> [term] {
    var res:[term] = []
    for i in 0..<a.count {
        for j in 0..<b.count {
            let new_coe:Double = a[i].coe * b[j].coe 
            let new_exp:Double = a[i].exp + b[j].exp
            var flag:Bool = true
            for k in 0..<res.count {
                if res[k].exp == new_exp {
                    res[k].coe += new_coe
                    flag = false
                }
            }
            if flag {
                res.append(term(coe:new_coe, exp:new_exp))
            }
        }
    }
    res.sort() { $0.exp > $1.exp }
    return res
}

func evaluated(poly:[term], x:Double) -> Double {
    var res = 0.0
    for i in 0..<poly.count {
        let coe = poly[i].coe
        let exp = poly[i].exp
        let tmp = coe * pow(x, exp)
        res += tmp
    }
    return res
}

func lagran(X:[Double], Y:[Double]) -> [term] {
    var res:[term] = []
    for i in 0..<X.count {
        var tmp:[term] = [term(coe:Y[i], exp:0)]
        for j in 0..<X.count {
            if i != j {
                let poly:[term] = [term(coe:1, exp:1), term(coe:X[j], exp:0)]
                tmp = tmp * poly
                for k in 0..<tmp.count {
                    tmp[k].coe /= (X[i] - X[j])
                }
            }
        }
        res = res + tmp
    }
    return res
}

func lagrange(X: [Double], Y: [Double], x: Double) -> Double {
    var result = 0.0
    for i in 0..<X.count {
        var temp = Y[i]
        for j in 0..<X.count {
            if i != j {
                temp *= (x - X[j])
                temp /= (X[i] - X[j])
            }
        }
        result += temp
    }
    return result
}

func print_poly(res: [term]) {
    for i in 0..<res.count {
        let coe = (i == 0) ? String(format: "%.10e", res[i].coe) : String(format: "%.10e", abs(res[i].coe))
        let exp = Int(res[i].exp)
        switch exp {
            case 0: print("\(coe)", terminator: "")
            case 1: print("\(coe) x", terminator: "")
            default: print("\(coe) x^\(exp)", terminator: "")
        }
        if i == res.count - 1 {
            break;
        }
        if res[i + 1].coe >= 0.0 {
            print(" + ",  terminator: "")
        } else {
            print(" - ", terminator:"")
        }
    }
    print("")
}

func function(X:[Double]) -> [Double] {
    var Y = [Double](repeating: 0, count: X.count)
    for i in 0..<X.count {
        Y[i] = 1.0 / (1 + X[i] * X[i])
    }
    return Y
}

func deviation(min:Double, max:Double, points:Int, lag:[term]) -> Double {
    let increments = (max - min) / Double(points - 1)
    var _x:[Double] = []
    var res1:[Double] = []
    for i in 0..<points {
        let tmpx = min + Double(i) * increments
        _x.append(tmpx)
        res1.append(evaluated(poly:lag, x:tmpx))
    }
    let res2 = function(X:_x)
    var delta:Double = 0;
    for i in 0..<points {
        delta += abs(res1[i] - res2[i])
    }
    delta /= Double(points)
    return delta
}

var X:[Double] = [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
var Y:[Double] = function(X:X)
 

var res = lagran(X:X, Y:Y)
print_poly(res:res)

print(deviation(min:-5, max:5, points:101, lag:res))


输出：


-2.2624434389e-05 x^10 + 1.5252548751e-19 x^9 + 1.2669683258e-03 x^8 + 1.2327293998e-17 x^7 - 2.4411764706e-02 x^6 - 1.0038526271e-16 x^5 + 1.9737556561e-01 x^4 + 1.2603850255e-18 x^3 - 6.7420814480e-01 x^2 + 1.4776997985e-16 x + 1.0000000000e+00


0.285755403658762

MoeO3
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
工业大数据分析指南材料整理
RayChiu757374816的博客
10-14 3793
工业大数据分析指南
拉格朗日插值法
最新发布
xiaofeixia002X的博客
06-24 332
拉格朗日插值法（Lagrange Interpolation）是一种用于通过给定数据点构造多项式的插值方法。其基本思想是通过线性组合一系列基函数（拉格朗日基函数）来构造插值多项式，使得该多项式在每个已知数据点处与数据点的函数值相等。
BAT机器学习面试1000题系列（第1~305题）
Smile to the World
11-10 3823
BAT机器学习面试1000题系列 整理：July、元超、立娜、德伟、贾茹、王剑、AntZ、孟莹等众人。本系列大部分题目来源于公开网络，取之分享，用之分享，且在撰写答案过程中若引用他人解析则必注明原作者及来源链接。另，不少答案得到寒小阳、管博士、张雨石、王赟、褚博士等七月在线名师审校。 说明：本系列作为国内首个AI题库，首发于七月在线...
zoj训练指南
acm_1361677193的专栏
01-20 5980
链接： http://blog.csdn.net/wss0130/article/details/7880019 恋&空的专栏 目录视图摘要视图订阅
机器学习面试
yan31415的博客
06-19 6218
BAT机器学习面试1000题系列 整理：July、元超、立娜、德伟、贾茹、王剑、AntZ、孟莹等众人。本系列大部分题目来源于公开网络，取之分享，用之分享，且在撰写答案过程中若引用他人解析则必注明原作者及来源链接。另，不少答案得到寒小阳、管博士、张雨石、王赟、褚博士等七月在线名师审校。 说明：本系列作为国内首个AI题库，首...
深度学习基础知识整理
热门推荐
kwame211的博客
07-23 3万+
本文是在七月的BAT机器学习面试1000题系列进行修改。  前言     July我又回来了。     之前本博客整理过数千道微软等公司的面试题，侧重数据结构、算法、海量数据处理，详见：微软面试100题系列，今17年，近期和团队整理BAT机器学习面试1000题系列，侧重机器学习、深度学习。我们将通过这个系列索引绝大部分机器学习和深度学习的笔试面试题、知识点，它将更是一个足够庞大的机器学习和深...
BAT机器学习面试1000题系列（第1~305题
小爽哒哒哒的博客
09-29 1万+
1 请简要介绍下SVM，机器学习 ML模型 易SVM，全称是support vector machine，中文名叫支持向量机。SVM是一个面向数据的分类算法，它的目标是为确定一个分类超平面，从而将不同的数据分隔开。 扩展：这里有篇文章详尽介绍了SVM的原理、推导，《支持向量机通俗导论（理解SVM的三层境界）》。此外，这里有个视频也是关于SVM的推导：《纯白板手推SVM》   2 请简要介绍下t...
BAT机器学习面试1000题系列
ytusdc的博客
12-22 5691
BAT机器学习面试1000题系列   原文地址：http://blog.csdn.net/v_july_v/article/details/78121924   整理：July、元超、立娜、德伟、贾茹、王剑、AntZ、孟莹等众人。本系列大部分题目来源于公开网络，取之分享，用之分享，且在撰写答案过程中若引用他人解析则必注明原作者及来源链接。另，不少答案得到寒小阳、管博士、张雨...
AAAI2021论文列表（中英对照）
dovings的博客
07-04 8070
AAAI2021论文列表（中英对照）
缺失值处理：拉格朗日插值法
12-21
在若干个不同的地方得到相应的观测值，拉格朗日插值法可以找到一个多项式，其恰好在各个观测的点取到观测到的值。这样的多项式称为拉格朗日（插值）多项式。数学上来说，拉格朗日插值法可以给出一个恰好穿过二维平面...
c代码-拉格朗日插值法
07-14
拉格朗日插值法是一种在离散数据点上构建多项式函数的方法，它通过构造一个特殊的多项式来近似给定数据集的函数。在C语言中实现拉格朗日插值法可以帮助我们处理一些数值计算问题，比如数据拟合、函数估算等。以下是...
【拉格朗日插值法】拉格朗日插值法介绍
04-11
拉格朗日插值法就是构造一个多项式，使得恰好在每一个x处取到对应的y 首先，n+1个点(xi,yi)若xi不同，则可以确定唯一的最高幂次不超过n的多项式。而如果题目直接或是间接给出了n+1个点，让我们求由这些点构成的...
数学建模之拉格朗日插值法
10-04
拉格朗日插值法
Python实现的拉格朗日插值法示例
09-19
主要介绍了Python实现的拉格朗日插值法,简单介绍了拉格朗日插值法的原理并结合完整实例形式给出了拉格朗日插值法的具体实现与使用技巧,需要的朋友可以参考下
【倍增】【set】[NOIP2012] codevs1199 开车旅行
每天心塞一点点
10-18 2391
题目点这里 这题的复杂度基本就在预处理找在每个点A、B分别要开去哪上面了 = =倍增其实很水…… 用set维护高度。因为只能从前往后，所以从后往前插入，然后取其前两个和后两个用他们之间的距离排个序，距离最小的是B去的地方，第二小是A去的地方。 记A+B各开一次为一轮。然后令f[i][j]为从i出发，开了2^j轮去了哪。fa[i][j]、fb[i][j]分别表示从a、b出发走2^j轮后
【最短路】【bfs】[NOIP2013] codevs3290 华容道
每天心塞一点点
09-26 1407
记得这题暴力有70...十分良心，然而它卡A*……（好像A*的估值很忧伤） 本来YY出了很诡异的姿势。。然后发现很难写……想弃疗…… 最后还是按网上流传的方法做的..不过网上的代码都好繁琐啊 = =差评…… 太久没有写代码真的生疏了不少..代码能力掉的很厉害。所以啊很多东西很久不碰也许就会忘掉了 还好最后还是成功AC掉了，谢天谢地 注意：1.加边不能加双向，因为虚拟节点可能会捣乱
【最小割】【图的点连通度】破坏图
每天心塞一点点
03-13 960
【题目描述】 一个图有n个点，m条边（有向边），要从起点1到终点n。破坏中间的一些点，使得从起点 到终点经过的边数必须大于k条。求最少要破坏多少个点。 起点和终点是不能被破坏的。数据保证不存在起点到终点的边。 注：起点和终点不连通视为距离无穷大。 【输入】 第一行读入三个正整数n,m,k。n表示点的个数，m表示边的条数，k表示从起点到终点经过 的边数必须大于k条。 接下来m行，每行
【参考代码】mz线段树基本操作训练
每天心塞一点点
05-06 845
QAQ为什么高一小朋友们的题都这么难。。 代码仅供参考，禁止照抄哦 = v = 说明一下：read()函数是读入优化，你们直接写scanf就行了。namespace只是为了封装，可以不要。 然后我线段树的姿势可能和你们老师讲的不太一样，个人觉得这样写起来简洁一些，而且效率高。 Promble A 原题是hdu1166。简单的点修改和区间查询。因为太水了我就写的树状数组 =
拉格朗日插值法详解及Matlab实现
"这篇内容主要介绍了拉格朗日插值法在MATLAB环境中的应用，是数学建模与数学实验的一部分，旨在让学生了解并掌握插值的基本概念和方法，包括一维和二维插值，特别是拉格朗日插值、分段线性插值和三次样条插值等。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值