From 12f27aa7dbe3c7dc19a27e73ddfc1aad9b4f6b9e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=94=A6=E4=B8=8A=E8=8A=B1=E4=B8=80=E7=9B=8F?= <110328934+jimes3@users.noreply.github.com> Date: Sun, 15 Sep 2024 21:56:38 +0800 Subject: [PATCH] Site updated: 2024-09-15 21:56:38 --- .../index.html" | 15 ++++++++++- .../index.html" | 15 ++++++++++- .../index.html" | 15 ++++++++++- .../index.html" | 15 ++++++++++- .../index.html" | 15 ++++++++++- .../index.html" | 15 ++++++++++- .../ARIMA\351\242\204\346\265\213/index.html" | 15 ++++++++++- .../ARMA\351\242\204\346\265\213/index.html" | 15 ++++++++++- .../11/AR\351\242\204\346\265\213/index.html" | 15 ++++++++++- .../11/MA\351\242\204\346\265\213/index.html" | 15 ++++++++++- .../index.html" | 15 ++++++++++- .../index.html" | 15 ++++++++++- .../index.html" | 15 ++++++++++- .../index.html" | 15 ++++++++++- .../index.html" | 15 ++++++++++- .../index.html" | 15 ++++++++++- .../index.html" | 15 ++++++++++- .../index.html" | 15 ++++++++++- 2024/10/01/PDF_math/index.html | 15 ++++++++++- 404.html | 15 ++++++++++- about/index.html | 15 ++++++++++- archives/2024/01/index.html | 15 ++++++++++- archives/2024/02/index.html | 15 ++++++++++- archives/2024/07/index.html | 15 ++++++++++- archives/2024/09/index.html | 15 ++++++++++- archives/2024/09/page/2/index.html | 1 - archives/2024/10/index.html | 15 ++++++++++- archives/2024/index.html | 15 ++++++++++- archives/2024/page/2/index.html | 1 - archives/index.html | 15 ++++++++++- archives/page/2/index.html | 1 - categories/index.html | 15 ++++++++++- .../index.html" | 15 ++++++++++- .../index.html" | 15 ++++++++++- .../index.html" | 15 ++++++++++- .../page/2/index.html" | 1 - .../\346\270\270\346\210\217/index.html" | 15 ++++++++++- .../index.html" | 15 ++++++++++- .../\350\200\203\347\240\224408/index.html" | 15 ++++++++++- index.html | 15 ++++++++++- links/index.html | 15 ++++++++++- page/2/index.html | 1 - sitemap.xml | 26 +++++++++---------- sw-register.js | 2 +- sw.js | 2 +- tags/index.html | 15 ++++++++++- 46 files changed, 547 insertions(+), 58 deletions(-) delete mode 100644 archives/2024/09/page/2/index.html delete mode 100644 archives/2024/page/2/index.html delete mode 100644 archives/page/2/index.html delete mode 100644 "categories/\346\225\260\345\255\246\345\273\272\346\250\241/page/2/index.html" delete mode 100644 page/2/index.html diff --git "a/2024/01/09/GitHub desktop\345\237\272\346\234\254\347\224\250\346\263\225/index.html" "b/2024/01/09/GitHub desktop\345\237\272\346\234\254\347\224\250\346\263\225/index.html" index bd0e9aa..1422eec 100644 --- "a/2024/01/09/GitHub desktop\345\237\272\346\234\254\347\224\250\346\263\225/index.html" +++ "b/2024/01/09/GitHub desktop\345\237\272\346\234\254\347\224\250\346\263\225/index.html" @@ -1 +1,14 @@ -GitHub desktop 基本用法 - 马锦的博客

GitHub desktop 基本用法

一，仓库

1.1新建仓库

1，点击File,再点击new repository。

2，通过新建仓库可以实时的在GitHub和GitHub desktop中创建一个空的仓库，你可以对新建的仓库进行各项设置。

包括仓库名字，仓库描述，仓库本地位置，自动创建readme文件，忽略文件的选择，以及开源许可证的选择。这里介绍后两个的详细内容：

git ignore可以选择忽略文件，如果你有些文件并不想上传，那你就可以将其设置。

以下是一个示例 .gitignore 文件：

1
2
3
4
5
6
7
8
9
10
11
12
13

# Ignore node_modules folder   忽略文件夹
node_modules/

# Ignore build artifacts    忽略目录
build/
dist/
*.log

# Ignore configuration files   忽略文件
.env
config.js

这将忽略 node_modules 文件夹、build 和 dist 目录、所有以 .log 结尾的文件以及 .env 和 config.js 文件。

license为许可证设置，设置许可证的目的是为了让别人可以合理合法地使用与修改我们的代码，有多种许可证可以选择，它们具有不同的权限设置。

总结一下，MIT 最自由，简直就是没有任何限制，任何人都可以售卖我的软件，甚至可以用我的名字促销。BSD 和 Apache 协议也很自由，跟 MIT 的区别分别是不允许用作者本人名义促销和保护作者版权。GPL 可以说最霸道，对代码的修改部分也必须是 GPL 的，同时基于 GPL 代码而开发的代码也必须按照 GPL 发布，而 MPL ，也就是 Mozilla Public License 就温和一些，如果后续开发的代码中添加了新文件，同时新文件中也没有用到原来的代码，那么新文件可以不必继续沿用 MPL 。【如何为自己的 Github 项目选择开源许可证？ - 知乎 (zhihu.com)】

3，当你完成了前两步，你还需要点击Publish repository来上传仓库，并设置仓库是否公开（这很重要！）

1.2添加本地仓库

1，点击File，再点击Ddd local repository。

2，输入本地文件地址，但如果你的文件未初始化为git仓库，则需要点击create a repository来新建一个仓库（作用是将选定的文件初始化为git仓库）

3，点击后则与上面一样，进行各种参数填充。

1.3克隆仓库

1，点击File，再点击Clone repository。

2，选择需要克隆的仓库，如果你是要克隆别人的仓库，可以选择URL

1.4编辑仓库

  • 点击open in ········，如果这个编辑器不是你喜欢的，你可以点击绿色的Options进行编辑器的选择。

1.5删除仓库

  • 删除仓库并不会删除GitHub上的仓库，更多的作用是删除本地与GitHub的连接！

如果你想切断GitHub与本地库的连接，你可以执行以下操作：

  1. 删除本地库中的.git文件夹（这是一个隐藏文件夹，你需要启用显示隐藏文件夹选项）

  2. 如果你想从GitHub上删除该库，你可以在GitHub上进入该库，点击“Settings”，然后在“Danger Zone”中点击“Delete this repository”。

这里推荐使用GitHub desktop进行删除操作：

右击需要删除的仓库

在被删除仓库页面，点击Repository，再点击Remove

你会看到如下页面，勾选下方选项框的话，会将你的仓库从计算机硬盘中移除；如果不勾选，只会在GitHub desktop（GitHub）上移除。

二，版本控制

2.1更新版本

1，GitHub desktop会自动识别仓库里代码的变动，并且你可选择应用哪些改变。如果你改变了仓库链接的本地仓库文件，你可以在GitHub desktop的主页面上看到如下场景：

我在仓库中新建了‘版本更新.py’文件，并在其中写入了print(’dddd’)代码

2，可以看到左侧栏中出现了changes，你需要在左下角的summary中填入摘记（必填），还可以填入相关描述，填入后，你还需要点击Push origin上传：

3，这时你就可以在GitHub上看到你的仓库发生了变化：

2.2项目回滚

1，你可以在History里看到每一次的版本变化：

2，具体操作：

  • 点击History
  • 选择要回滚的版本
  • 右键选择Revert Changes in Commit
  • 确认回滚信息并提交

可以看到版本回到了最开始的样子。

三，分支管理

3.1新建分支

  • 点击Current brance
  • 点击New brance
  • 然后为你的分支命名即可
  • 在GitHub中查看分支

创建分支

3.2切换分支

点击即可

在GitHub desktop选择分支

在GitHub查看与选择分支

3.3合并分支

  1. 首先，在 GitHub Desktop 中打开你要合并的仓库。

  2. 点击左侧导航栏中的“分支”选项卡，找到你要合并的分支。

  3. 选择要合并的分支，右键点击该分支并选择“Merge into current branch”（合并到当前分支）选项。

  4. 确认合并操作，如果有冲突需要手动解决冲突。

  5. 点击“Commit merge”（提交合并）按钮。

  6. 最后点击“Push origin”（推送到远程仓库）按钮，将合并后的代码推送到远程仓库。

3.4删除分支

  • 右键删除即可

3.5比较分支

  • 在 GitHub Desktop 中打开你要合并的仓库。
  • 点击Compare to brance

  • 在左侧搜索需要对比的即可

3.6查看提交历史

  • 在想要查看的分支下点击Hitory

四，多人协作

  1. 创建GitHub仓库：首先，一个人（通常是项目的负责人）在GitHub上创建一个仓库，并将其与本地项目相关联。
  2. 邀请协作者：负责人可以通过在GitHub仓库的设置中添加协作者来邀请其他人加入项目。在协作者的GitHub帐户上，他们将收到邀请加入项目的通知。

在仓库设置里，点击Collabarators即可

  1. 克隆仓库：协作者使用GitHub Desktop克隆项目的仓库到本地。他们可以选择克隆到自己的计算机上的任意位置。
  2. 进行更改：每个协作者在本地进行代码更改或其他操作。他们可以使用GitHub Desktop的界面进行提交更改。
  3. 提交更改：协作者完成更改后，使用GitHub Desktop提交他们的更改到GitHub仓库。他们可以添加有关更改的说明和描述。
  4. 解决冲突：如果两个或多个协作者在相同的文件的相同行进行了更改，可能会出现冲突。在这种情况下，GitHub Desktop会提醒协作者，让他们解决冲突。协作者可以使用GitHub Desktop提供的冲突解决工具来处理冲突。
  5. 更新本地仓库：协作者可以通过点击GitHub Desktop中的”Pull”按钮来获取最新的更改。这将从GitHub仓库中拉取其他协作者提交的更改并合并到本地仓库。

  1. 推送更改：协作者在本地完成更改后，可以使用GitHub Desktop的”Push”按钮将更改推送到GitHub仓库。这将把他们的更改上传到仓库并使其他协作者可见。

通过这些步骤，多人可以使用GitHub Desktop进行协作开发，并实时共享和同步他们的更改。在整个过程中，GitHub Desktop提供了一个简单直观的界面，帮助协作者进行版本控制和协作。

基础工具
GitHub desktop 基本用法
https://jimes.cn/2024/01/09/GitHub desktop基本用法/
作者
Jimes
发布于
2024年1月9日
许可协议
\ No newline at end of file +GitHub desktop 基本用法 - 马锦的博客

GitHub desktop 基本用法

一，仓库

1.1新建仓库

1，点击File,再点击new repository。

2，通过新建仓库可以实时的在GitHub和GitHub desktop中创建一个空的仓库，你可以对新建的仓库进行各项设置。

包括仓库名字，仓库描述，仓库本地位置，自动创建readme文件，忽略文件的选择，以及开源许可证的选择。这里介绍后两个的详细内容：

git ignore可以选择忽略文件，如果你有些文件并不想上传，那你就可以将其设置。

以下是一个示例 .gitignore 文件：

1
2
3
4
5
6
7
8
9
10
11
12
13

# Ignore node_modules folder   忽略文件夹
node_modules/

# Ignore build artifacts    忽略目录
build/
dist/
*.log

# Ignore configuration files   忽略文件
.env
config.js

这将忽略 node_modules 文件夹、build 和 dist 目录、所有以 .log 结尾的文件以及 .env 和 config.js 文件。

license为许可证设置，设置许可证的目的是为了让别人可以合理合法地使用与修改我们的代码，有多种许可证可以选择，它们具有不同的权限设置。

总结一下，MIT 最自由，简直就是没有任何限制，任何人都可以售卖我的软件，甚至可以用我的名字促销。BSD 和 Apache 协议也很自由，跟 MIT 的区别分别是不允许用作者本人名义促销和保护作者版权。GPL 可以说最霸道，对代码的修改部分也必须是 GPL 的，同时基于 GPL 代码而开发的代码也必须按照 GPL 发布，而 MPL ，也就是 Mozilla Public License 就温和一些，如果后续开发的代码中添加了新文件，同时新文件中也没有用到原来的代码，那么新文件可以不必继续沿用 MPL 。【如何为自己的 Github 项目选择开源许可证？ - 知乎 (zhihu.com)】

3，当你完成了前两步，你还需要点击Publish repository来上传仓库，并设置仓库是否公开（这很重要！）

1.2添加本地仓库

1，点击File，再点击Ddd local repository。

2，输入本地文件地址，但如果你的文件未初始化为git仓库，则需要点击create a repository来新建一个仓库（作用是将选定的文件初始化为git仓库）

3，点击后则与上面一样，进行各种参数填充。

1.3克隆仓库

1，点击File，再点击Clone repository。

2，选择需要克隆的仓库，如果你是要克隆别人的仓库，可以选择URL

1.4编辑仓库

  • 点击open in ········，如果这个编辑器不是你喜欢的，你可以点击绿色的Options进行编辑器的选择。

1.5删除仓库

  • 删除仓库并不会删除GitHub上的仓库，更多的作用是删除本地与GitHub的连接！

如果你想切断GitHub与本地库的连接，你可以执行以下操作：

  1. 删除本地库中的.git文件夹（这是一个隐藏文件夹，你需要启用显示隐藏文件夹选项）

  2. 如果你想从GitHub上删除该库，你可以在GitHub上进入该库，点击“Settings”，然后在“Danger Zone”中点击“Delete this repository”。

这里推荐使用GitHub desktop进行删除操作：

右击需要删除的仓库

在被删除仓库页面，点击Repository，再点击Remove

你会看到如下页面，勾选下方选项框的话，会将你的仓库从计算机硬盘中移除；如果不勾选，只会在GitHub desktop（GitHub）上移除。

二，版本控制

2.1更新版本

1，GitHub desktop会自动识别仓库里代码的变动，并且你可选择应用哪些改变。如果你改变了仓库链接的本地仓库文件，你可以在GitHub desktop的主页面上看到如下场景：

我在仓库中新建了‘版本更新.py’文件，并在其中写入了print(’dddd’)代码

2，可以看到左侧栏中出现了changes，你需要在左下角的summary中填入摘记（必填），还可以填入相关描述，填入后，你还需要点击Push origin上传：

3，这时你就可以在GitHub上看到你的仓库发生了变化：

2.2项目回滚

1，你可以在History里看到每一次的版本变化：

2，具体操作：

  • 点击History
  • 选择要回滚的版本
  • 右键选择Revert Changes in Commit
  • 确认回滚信息并提交

可以看到版本回到了最开始的样子。

三，分支管理

3.1新建分支

  • 点击Current brance
  • 点击New brance
  • 然后为你的分支命名即可
  • 在GitHub中查看分支

创建分支

3.2切换分支

点击即可

在GitHub desktop选择分支

在GitHub查看与选择分支

3.3合并分支

  1. 首先，在 GitHub Desktop 中打开你要合并的仓库。

  2. 点击左侧导航栏中的“分支”选项卡，找到你要合并的分支。

  3. 选择要合并的分支，右键点击该分支并选择“Merge into current branch”（合并到当前分支）选项。

  4. 确认合并操作，如果有冲突需要手动解决冲突。

  5. 点击“Commit merge”（提交合并）按钮。

  6. 最后点击“Push origin”（推送到远程仓库）按钮，将合并后的代码推送到远程仓库。

3.4删除分支

  • 右键删除即可

3.5比较分支

  • 在 GitHub Desktop 中打开你要合并的仓库。
  • 点击Compare to brance

  • 在左侧搜索需要对比的即可

3.6查看提交历史

  • 在想要查看的分支下点击Hitory

四，多人协作

  1. 创建GitHub仓库：首先，一个人（通常是项目的负责人）在GitHub上创建一个仓库，并将其与本地项目相关联。
  2. 邀请协作者：负责人可以通过在GitHub仓库的设置中添加协作者来邀请其他人加入项目。在协作者的GitHub帐户上，他们将收到邀请加入项目的通知。

在仓库设置里，点击Collabarators即可

  1. 克隆仓库：协作者使用GitHub Desktop克隆项目的仓库到本地。他们可以选择克隆到自己的计算机上的任意位置。
  2. 进行更改：每个协作者在本地进行代码更改或其他操作。他们可以使用GitHub Desktop的界面进行提交更改。
  3. 提交更改：协作者完成更改后，使用GitHub Desktop提交他们的更改到GitHub仓库。他们可以添加有关更改的说明和描述。
  4. 解决冲突：如果两个或多个协作者在相同的文件的相同行进行了更改，可能会出现冲突。在这种情况下，GitHub Desktop会提醒协作者，让他们解决冲突。协作者可以使用GitHub Desktop提供的冲突解决工具来处理冲突。
  5. 更新本地仓库：协作者可以通过点击GitHub Desktop中的”Pull”按钮来获取最新的更改。这将从GitHub仓库中拉取其他协作者提交的更改并合并到本地仓库。

  1. 推送更改：协作者在本地完成更改后，可以使用GitHub Desktop的”Push”按钮将更改推送到GitHub仓库。这将把他们的更改上传到仓库并使其他协作者可见。

通过这些步骤，多人可以使用GitHub Desktop进行协作开发，并实时共享和同步他们的更改。在整个过程中，GitHub Desktop提供了一个简单直观的界面，帮助协作者进行版本控制和协作。

基础工具
GitHub desktop 基本用法
https://jimes.cn/2024/01/09/GitHub desktop基本用法/
作者
Jimes
发布于
2024年1月9日
许可协议
+ + \ No newline at end of file diff --git "a/2024/01/10/\344\272\272\345\267\245\346\231\272\350\203\275\345\255\246\344\271\240\345\257\274\350\210\252/index.html" "b/2024/01/10/\344\272\272\345\267\245\346\231\272\350\203\275\345\255\246\344\271\240\345\257\274\350\210\252/index.html" index 2c1ff8f..3b6450c 100644 --- "a/2024/01/10/\344\272\272\345\267\245\346\231\272\350\203\275\345\255\246\344\271\240\345\257\274\350\210\252/index.html" +++ "b/2024/01/10/\344\272\272\345\267\245\346\231\272\350\203\275\345\255\246\344\271\240\345\257\274\350\210\252/index.html" @@ -1 +1,14 @@ -人工智能学习导航 - 马锦的博客

人工智能学习导航

1，机器学习算法python实现

GitHub项目，讲解了机器学习算法的数学原理与python实现，做笔记必备。

2，Hello算法

数据结构类的算法的多方式实现，有c，python，c++等等，同时配备了可视化界面，形象讲解算法的原理与区别。

3，可视化数据结构与算法

一个单纯模拟数据结构算法的网站。

4，菜鸟教程

学计算机必备，各种语言与第三方库的讲解以及框架，数不胜数！

5，神经网络与深度学习

邱锡鹏教授出版，详细功能见网址上级GitHub仓库，具有以下特点：

系统性：系统地整理了神经网络和深度学习的知识体系。鉴于深度学习涉及的知识点较多，本书从机器学习的基本概念、神经网络模型以及概率图模型三个层面来串联深度学习所涉及的知识点，使读者对深度学习技术的理解更具系统性、条理性和全面性。
可读性：本书在编排上由浅入深，在语言表达上力求通俗易懂，并通过增加图例、示例以及必要的数学推导来理解抽象的概念。同时，附录简要介绍了本书所涉及的必要数学知识，便于读者查用。
实践性：本书在网站上配套了针对每章知识点的编程练习，使得读者在学习过程中可以将理论和实践密切结合，加深对知识点的理解，并具备分析问题和解决问题的能力。

6，小林coding

图解计算机网络、操作系统、计算机组成、数据库，让天下没有难懂的八股文！

人工智能
人工智能学习导航
https://jimes.cn/2024/01/10/人工智能学习导航/
作者
Jimes
发布于
2024年1月10日
许可协议
\ No newline at end of file +人工智能学习导航 - 马锦的博客

人工智能学习导航

1，机器学习算法python实现

GitHub项目，讲解了机器学习算法的数学原理与python实现，做笔记必备。

2，Hello算法

数据结构类的算法的多方式实现，有c，python，c++等等，同时配备了可视化界面，形象讲解算法的原理与区别。

3，可视化数据结构与算法

一个单纯模拟数据结构算法的网站。

4，菜鸟教程

学计算机必备，各种语言与第三方库的讲解以及框架，数不胜数！

5，神经网络与深度学习

邱锡鹏教授出版，详细功能见网址上级GitHub仓库，具有以下特点：

系统性：系统地整理了神经网络和深度学习的知识体系。鉴于深度学习涉及的知识点较多，本书从机器学习的基本概念、神经网络模型以及概率图模型三个层面来串联深度学习所涉及的知识点，使读者对深度学习技术的理解更具系统性、条理性和全面性。
可读性：本书在编排上由浅入深，在语言表达上力求通俗易懂，并通过增加图例、示例以及必要的数学推导来理解抽象的概念。同时，附录简要介绍了本书所涉及的必要数学知识，便于读者查用。
实践性：本书在网站上配套了针对每章知识点的编程练习，使得读者在学习过程中可以将理论和实践密切结合，加深对知识点的理解，并具备分析问题和解决问题的能力。

6，小林coding

图解计算机网络、操作系统、计算机组成、数据库，让天下没有难懂的八股文！

人工智能
人工智能学习导航
https://jimes.cn/2024/01/10/人工智能学习导航/
作者
Jimes
发布于
2024年1月10日
许可协议
+ + \ No newline at end of file diff --git "a/2024/01/12/python\347\250\213\345\272\217\345\270\246\345\233\276\347\211\207\347\255\211\350\265\204\346\272\220\346\211\223\345\214\205/index.html" "b/2024/01/12/python\347\250\213\345\272\217\345\270\246\345\233\276\347\211\207\347\255\211\350\265\204\346\272\220\346\211\223\345\214\205/index.html" index dabcb9e..a842806 100644 --- "a/2024/01/12/python\347\250\213\345\272\217\345\270\246\345\233\276\347\211\207\347\255\211\350\265\204\346\272\220\346\211\223\345\214\205/index.html" +++ "b/2024/01/12/python\347\250\213\345\272\217\345\270\246\345\233\276\347\211\207\347\255\211\350\265\204\346\272\220\346\211\223\345\214\205/index.html" @@ -1 +1,14 @@ -python程序带图片等资源打包 - 马锦的博客

python程序带图片等资源打包

1
2
3
#在打包时，都需要将终端运行地址切换到要打包文件的父目录下
#在终端中运行以下代码
cd 父目录地址

1，常规打包

1
2
3
4
5
6
7
Pyinstaller -F py_word.py     #打包成单独exe，在文件夹dist中的单独文件

Pyinstaller -F -w py_word.py     #不带控制台的打包，不建议，会导致静默运行，只能从运行管理器中找到并停止

Pyinstaller -F -w -i chengzi.ico py_word.py     #打包指定exe图标打包

pyinstaller -F --uac-admin word.py    #打包的程序以管理员身份运行

如果打包过大，可以使用anaconda创建虚拟环境只下载需要的第三方库。

2，带资源打包

2.1 首先解决的问题：打包后代码里资源的地址会因在不同环境下运行而不同。

首先需要将图片放到代码同级文件夹内，同时更新代码内的图片地址，这样做是为了后期能够批量打包图片等资源。

这里通过文件运行的绝对路径结合图片的相对路径来生成图片的绝对路径。将以下函数代码复制到打包代码中：

1
2
3
4
def get_resource_path(relative_path):
    if hasattr(sys, '_MEIPASS'):
        return os.path.join(sys._MEIPASS, relative_path)
    return os.path.join(os.path.abspath("."), relative_path)

定义了函数后，将代码里的图片地址统一换为：

1
get_resource_path('原代码里的图片地址')

2.2 开始进行打包

  1. -add-data后面可以加=，也可以直接空格，效果一样。
  2. -add-data后面的参数值里，有两部分，用 : 或者 ;隔开，前面是指打包前文件所在的位置，后面是指打包后你希望文件所在的位置。比如样例里的：-add-data="image1.png:img" 的意思是把当前目录里一个叫 “image1.png” 的文件打包进去，但是放在打包后的 “img” 目录下，也就是变成 img/image1.png，文件名不变。
  3. -add-data可以用好多次，也就是可以一个文件一个文件地加。
  4. 整个文件夹一起加：-add-data 'images:images' 也就是把当前目录下 images 文件夹里的文件都打包进去，打包后的目录也是 images 一样的文件夹下。

最终在终端运行的代码：

1
pyinstaller --add-data 'images:images' -F --uac-admin py_name.py
基础工具
python程序带图片等资源打包
https://jimes.cn/2024/01/12/python程序带图片等资源打包/
作者
Jimes
发布于
2024年1月12日
许可协议
\ No newline at end of file +python程序带图片等资源打包 - 马锦的博客

python程序带图片等资源打包

1
2
3
#在打包时，都需要将终端运行地址切换到要打包文件的父目录下
#在终端中运行以下代码
cd 父目录地址

1，常规打包

1
2
3
4
5
6
7
Pyinstaller -F py_word.py     #打包成单独exe，在文件夹dist中的单独文件

Pyinstaller -F -w py_word.py     #不带控制台的打包，不建议，会导致静默运行，只能从运行管理器中找到并停止

Pyinstaller -F -w -i chengzi.ico py_word.py     #打包指定exe图标打包

pyinstaller -F --uac-admin word.py    #打包的程序以管理员身份运行

如果打包过大，可以使用anaconda创建虚拟环境只下载需要的第三方库。

2，带资源打包

2.1 首先解决的问题：打包后代码里资源的地址会因在不同环境下运行而不同。

首先需要将图片放到代码同级文件夹内，同时更新代码内的图片地址，这样做是为了后期能够批量打包图片等资源。

这里通过文件运行的绝对路径结合图片的相对路径来生成图片的绝对路径。将以下函数代码复制到打包代码中：

1
2
3
4
def get_resource_path(relative_path):
    if hasattr(sys, '_MEIPASS'):
        return os.path.join(sys._MEIPASS, relative_path)
    return os.path.join(os.path.abspath("."), relative_path)

定义了函数后，将代码里的图片地址统一换为：

1
get_resource_path('原代码里的图片地址')

2.2 开始进行打包

  1. -add-data后面可以加=，也可以直接空格，效果一样。
  2. -add-data后面的参数值里，有两部分，用 : 或者 ;隔开，前面是指打包前文件所在的位置，后面是指打包后你希望文件所在的位置。比如样例里的：-add-data="image1.png:img" 的意思是把当前目录里一个叫 “image1.png” 的文件打包进去，但是放在打包后的 “img” 目录下，也就是变成 img/image1.png，文件名不变。
  3. -add-data可以用好多次，也就是可以一个文件一个文件地加。
  4. 整个文件夹一起加：-add-data 'images:images' 也就是把当前目录下 images 文件夹里的文件都打包进去，打包后的目录也是 images 一样的文件夹下。

最终在终端运行的代码：

1
pyinstaller --add-data 'images:images' -F --uac-admin py_name.py
基础工具
python程序带图片等资源打包
https://jimes.cn/2024/01/12/python程序带图片等资源打包/
作者
Jimes
发布于
2024年1月12日
许可协议
+ + \ No newline at end of file diff --git "a/2024/02/02/\346\225\260\346\215\256\347\273\223\346\236\204\344\271\213\347\272\277\346\200\247\350\241\250\344\273\243\347\240\201/index.html" "b/2024/02/02/\346\225\260\346\215\256\347\273\223\346\236\204\344\271\213\347\272\277\346\200\247\350\241\250\344\273\243\347\240\201/index.html" index 7360568..2182c8b 100644 --- "a/2024/02/02/\346\225\260\346\215\256\347\273\223\346\236\204\344\271\213\347\272\277\346\200\247\350\241\250\344\273\243\347\240\201/index.html" +++ "b/2024/02/02/\346\225\260\346\215\256\347\273\223\346\236\204\344\271\213\347\272\277\346\200\247\350\241\250\344\273\243\347\240\201/index.html" @@ -1 +1,14 @@ -数据结构之线性表代码 - 马锦的博客

数据结构之线性表代码

一，顺序表

1.1 顺序表的实现

静态实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#define MaxSize 10 // 定义最大长度 

typedef struct {
	int data[MaxSize]; // 使用静态的数组存放数据元素 
	int length; // 顺序表的当前长度 
}SqList;

// 初始化顺序表 
void InitList(SqList &L) {
	L.length = 0; // 顺序表初始长度为0 
}

int main() {
	SqList L; // 声明一个顺序表 
	InitList(L); // 初始化顺序表 
	return 0;
}

动态实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#define MaxSize 10 // 定义最大长度 
#define InitSize 10 // 顺序表的初始长度

typedef struct {
	int *data; // 声明动态分配数组的指针 
	int MaxSize; // 顺序表的最大容量
	int length; // 顺序表的当前长度 
}SeqList;

// 初始化顺序表 
void InitList(SeqList &L) {
	// 用malloc函数申请一片连续的存储空间 
	L.data = (int *)malloc(InitSize * sizeof(int));
	L.length = 0;
	L.MaxSize = InitSize;
}

// 增加动态数组的长度 ，非重点
void IncreaseSize(SeqList &L, int len) {
	int *p = L.data;
	L.data = (int *)malloc((L.MaxSize+len) * sizeof(int));
	for (int i = 0; i < L.length; i++)
		L.data[i] = p[i]; // 将数据复制到新区域 
	L.MaxSize = L.MaxSize + len; // 顺序表最大长度增加len 
	free(p); // 释放原来的内存空间 
}

int main() {
	SeqList L; // 声明一个顺序表 
	InitList(L); // 初始化顺序表 
    ...
	IncreaseSize(L, 5);
	return 0;
}

malloc() 函数的作用：会申请一片存储空间，并返回存储空间第一个位置的地址，也就是该位置的指针。

1.2 顺序表的基本操作

插入：

1
2
3
4
5
6
7
8
9
10
11
12
// 在顺序表i位置插入e
bool ListInsert(SqList &L, int i, int e) {
	if (i < 1 || i > L.length+1) // 判断i的范围是否有效 
		return false;
	if (L.length >= MaxSize) // 判断存储空间是否已满 
		return false;
	for (int j = L.length; j >= i; j--) // 将第i个元素之后的元素后移 
		L.data[j] = L.data[j-1];
	L.data[i-1] = e; // 在位置i处放入e 
	L.length++; // 长度+1 
	return true;
}

时间复杂度：

  • 最好时间复杂度：O ( 1 )
  • 最坏时间复杂度：O ( n )
  • 平均时间复杂度：O ( n )

删除：

1
2
3
4
5
6
7
8
9
10
// 删除顺序表i位置的数据并存入e
bool ListDelete(SqList &L, int i, int &e) {
	if (i < 1 || i > L.length) // 判断i的范围是否有效
		return false;
	e = L.data[i-1]; // 将被删除的元素赋值给e 
	for (int j = i; j < L.length; j++) //将第i个位置后的元素前移 
		L.data[j-1] = L.data[j];
	L.length--;
	return true; 
}

时间复杂度：

  • 最好时间复杂度：O ( 1 )
  • 最坏时间复杂度：O ( n )
  • 平均时间复杂度：O ( n )

按位查找：

1
2
3
4
5
6
// 静态分配的按位查找
#define MaxSize 10

ElemType GetElem(SqList L, int i) {
	return L.data[i-1];
}
1
2
3
4
5
6
// 动态分配的按位查找
#define InitSize 10

ElemType GetElem(SeqList L, int i) {
	return L.data[i-1];
}

时间复杂度： O ( 1 )

按值查找：

1
2
3
4
5
6
7
// 查找第一个元素值为e的元素，并返回其位序 
int LocateElem(SqList L, ElemType e) {
	for (int i = 0; i < L.length; i++)
		if (L.data[i] == e)
			return i+1; // 数组下标为i的元素值等于e，返回其位序i+1 
	return 0; // 没有查找到 
}

在《数据结构》考研初试中，手写代码可以直接用“==”，无论 ElemType 是基本数据类型还是结构类型

时间复杂度：

  • 最好时间复杂度：O ( 1 )
  • 最坏时间复杂度：O ( n )
  • 平均时间复杂度：O ( n )

二，单链表

2.1 单链表的实现

不带头结点的单链表：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

//初始化一个空的单链表
bool InitList(LinkList &L){
    L = NULL;//空表，暂时还没有任何结点
    return true;
}

void test(){
    LinkList L;//声明一个指向单链表的头指针
    //初始化一个空表
    InitList(L);
    ...
}

//判断单链表是否为空
bool Empty(LinkList L){
    return (L==NULL)
}

带头结点的单链表：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

// 初始化一个单链表（带头结点）
bool InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LNode));//分配一个头结点
    if (L == NULL)//内存不足，分配失败
    	return false;
    L->next = NULL;//头结点之后暂时还没有结点
    return true;
}

void test(){
    LinkList L;//声明一个指向单链表的头指针
    //初始化一个空表
    InitList(L);
    ...
}

//判断单链表是否为空
bool Empty(LinkList L){
    if (L->next == NULL)
        return true;
    else
        return false;
}

2.2 单链表的建立

尾插法建立单链表：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 使用尾插法建立单链表L
LinkList List_TailInsert(LinkList &L){
    int x;//设ElemType为整型int
    L = (LinkList)malloc(sizeof(LNode));//建立头结点(初始化空表)
    LNode *s, *r = L;//r为表尾指针
    scanf("%d", &x);//输入要插入的结点的值
    while(x!=9999){//输入9999表示结束
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        r = s;//r指针指向新的表尾结点
        scanf("%d", &x);
    }
    r->next = NULL;//尾结点指针置空
    return L;
}

时间复杂度：O ( n )

头插法建立单链表：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
LinkList List_HeadInsert(LinkList &L){//逆向建立单链表
    LNode *s;
    int x;
    L = (LinkList)malloc(sizeof(LNode));//建立头结点
    L->next = NULL;//初始为空链表,这步很关键
    scanf("%d", &x);//输入要插入的结点的值
    while(x!=9999){//输入9999表结束
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        s->next = L->next;
        L->next = s;
		//将新结点插入表中，L为头指针
		scanf("%d", &x);
    }
    return L;
}

头插法实现链表的逆置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 将链表L中的数据逆置并返回
LNode *Inverse(LNode *L){
    LNode *p, *q;
    p = L->next;//p指针指向第一个结点
    L->next = NULL;//头结点置空
    // 依次判断p结点中的数据并采用头插法插到L链表中
    while (p != NULL){
        q = p;
        p = p->next;
        q->next = L->next;
        L->next = q;
    }
    return L;
}

2.3 单链表的基本操作

按位序插入（带头结点）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

//在第i个位置插入元素e
bool ListInsert(LinkList &L, int i, ElemType e){
    if(i<1)
        return False;
    LNode *p; //指针p指向当前扫描到的结点
    int j=0;  //当前p指向的是第几个结点
    p = L;    //循环找到第i-1个结点
    while(p!=NULL && j<i-1){ //如果i>lengh，p最后会等于NULL
        p = p->next;
        j++;
    }
	//p值为NULL说明i值不合法
    if (p==NULL)
        return false;
	//在第i-1个结点后插入新结点
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
	//将结点s连到p后
    return true;
}

时间复杂度：

  • 最好时间复杂度：O ( 1 )
  • 最坏时间复杂度：O ( n )
  • 平均时间复杂度：O ( n )

按位序插入（不带头结点）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

//在第i个位置插入元素e
bool ListInsert(LinkList &L, int i, ElemType e){
	//判断i的合法性
    if(i<1)
        return false;
	//需要判断插入的位置是否是第1个
    if(i==1){
        LNode *s = (LNode *)malloc(size of(LNode));
        s->data =e;
        s->next =L;
        L=s;//头指针指向新结点
        return true;
    }
	//i>1的情况与带头结点一样，唯一区别是j的初始值为1
    LNode *p;//指针p指向当前扫描到的结点
    int j=1;//当前p指向的是第几个结点
    p = L;
	//循环找到第i-1个结点
    while(p!=NULL && j<i-1){//如果i>lengh，p最后会等于NULL
        p = p->next;
        j++;
    }
	//p值为NULL说明i值不合法
    if (p==NULL)
        return false;
	//在第i-1个结点后插入新结点
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

时间复杂度：

  • 最好时间复杂度：O ( 1 )
  • 最坏时间复杂度：O ( n )
  • 平均时间复杂度：O ( n )

除非特别声明，否则之后的代码都默认为带头结点

指定结点的后插操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

// 在结点p后插入元素e
bool InsertNextNode(LNode *p, ElemType e){
    if(p==NULL){
        return false;
    }
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if(s==NULL)
        return false;
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

// 按位序插入的函数中可以直接调用后插操作
bool ListInsert(LinkList &L, int i, ElemType e){
    if(i<1)
        return False;
    LNode *p;
	//指针p指向当前扫描到的结点
	int j=0;
	//当前p指向的是第几个结点
    p = L;
	//循环找到第i-1个结点
    while(p!=NULL && j<i-1){
	//如果i>lengh, p最后会等于NULL
        p = p->next;
        j++;
    }
    return InsertNextNode(p, e)
}

时间复杂度：O ( 1 )

指定结点的前插操作：

如果传入头指针，就可以循环整个链表找到指定结点p的前驱结点q，再对q进行后插操作；
如果不传入头指针，可以在指定结点p后插入一个结点s，并交换两个结点所保存的数据，从而变相实现指定结点的前插操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

// 在结点p前插入元素e
bool InsertPriorNode(LNode *p, ElemType e){
    if(p==NULL)
        return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
	// 内存不足分配失败
	if(s==NULL)
        return false;
	// 将s插入结点p之后
    s->next = p->next;
    p->next = s;
	// 交换两个结点中的数据
    s->data = p->data;
    p->data = e;
    return true;
}

时间复杂度：O ( 1 )

按位序删除：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
typedef struct LNode{
    ElemType data;
    struct LNode *next;}LNode, *LinkList;

// 删除第i个结点并将其所保存的数据存入e
bool ListDelete(LinkList &L, int i, ElemType &e){
    if(i<1)
        return false;
    LNode *p;//指针p指向当前扫描到的结点
    int j=0;//当前p指向的是第几个结点
    p = L;
	//循环找到第i-1个结点
    while(p!=NULL && j<i-1){
	//如果i>lengh，p和p的后继结点会等于NULL
        p = p->next;
        j++;
    }
    if(p==NULL)
        return false;
    if(p->next == NULL)
        return false;
//令q暂时保存被删除的结点
    LNode *q = p->next;
    e = q->data;
    p->next = q->next;
    free(q)
    return true;
}

时间复杂度：

  • 最好时间复杂度：O ( 1 )
  • 最坏时间复杂度：O ( n )
  • 平均时间复杂度：O ( n )

删除指定结点：

如果传入头指针，就可以循环整个链表找到指定结点p的前驱结点q，再对p进行删除操作；
如果不传入头指针，可以把指定结点p的后继结点q删除，并使结点p保存结点q存储的数据，从而变相实现删除指定结点的操作。但是如果指定结点p没有后继结点，这么做会报错。

1
2
3
4
5
6
7
8
9
10
// 删除指定结点p
bool DeleteNode(LNode *p){
    if(p==NULL)
        return false;
    LNode *q = p->next;// 令q指向p的后继结点// 如果p是最后一个结点，则q指向NULL，继续执行就会报错
    p->data = q->data;
    p->next = q->next;
    free(q);
    return true;
}

时间复杂度：O ( 1 )

按位查找：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

// 查找指定位序i的结点并返回
LNode * GetElem(LinkList L, int i){
    if(i<0)
        return NULL;
    LNode *p;
    int j=0;
    p = L;
    while(p!=NULL && j<i){
        p = p->next;
        j++;
    }
    return p;
}

// 封装后的插入操作，在第i个位置插入元素e，可以调用查询操作和后插操作
bool ListInsert(LinkList &L, int i, ElemType e){
    if(i<1)
        return False;
	// 找到第i-1个元素
    LNode *p = GetElem(L, i-1);
	// 在p结点后插入元素e
	return InsertNextNode(p, e)
}

时间复杂度：

  • 最好时间复杂度：O ( 1 )
  • 最坏时间复杂度：O ( n )
  • 平均时间复杂度：O ( n )

按值查找：

1
2
3
4
5
6
7
8
9
// 查找数据域为e的结点指针，否则返回NULL
LNode * LocateElem(LinkList L, ElemType e){
    LNode *P = L->next;
    // 从第一个结点开始查找数据域为e的结点
    while(p!=NULL && p->data != e){
        p = p->next;
    }
    return p;
}

时间复杂度：

  • 最好时间复杂度：O ( 1 )
  • 最坏时间复杂度：O ( n )
  • 平均时间复杂度：O ( n )

计算单链表长度：

1
2
3
4
5
6
7
8
9
10
// 计算单链表的长度
int Length(LinkList L){
    int len=0;//统计表长
    LNode *p = L;
    while(p->next != NULL){
        p = p->next;
        len++;
    }
    return len;
}

时间复杂度：O ( n )

三，双链表

双链表的初始化 (带头结点)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
typedef struct DNode{            //定义双链表结点类型
    ElemType data;               //数据域
    struct DNode *prior, *next;  //前驱和后继指针
}DNode, *DLinklist;

// 初始化双链表
bool InitDLinkList(Dlinklist &L){
    L = (DNode *)malloc(sizeof(DNode));
    if(L==NULL)
        return false;
    L->prior = NULL;//头结点的prior指针永远指向NULL
    L->next = NULL;//头结点之后暂时还没有结点，置空
    return true;
}

void testDLinkList(){
    DLinklist L;
    InitDLinkList(L);
    ...
}

// 判断双链表是否为空
bool Empty(DLinklist L){
    if(L->next == NULL)
        return true;
    else
        return false;
}

双链表的后插操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
typedef struct DNode{
    ElemType data;
    struct DNode *prior, *next;
}DNode, *DLinklist;

// 将结点s插入到结点p之后
bool InsertNextDNode(DNode *p, DNode *s){ 
    if(p==NULL || s==NULL)  
        return false;         
    s->next = p->next;      
    // 判断结点p之后是否有后继结点  
    if (p->next != NULL)   
        p->next->prior = s; 
    s->prior = p;   
    p->next = s;     
    return true;
}

双链表的前插操作、按位序插入操作都可以转换成后插操作

双链表的删除操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// 删除p结点的后继结点
bool DeletNextDNode(DNode *p){   
    if(p==NULL)           
        return false;   
    // 找到p的后继结点q    
    DNode *q =p->next;   
    if(q==NULL)          
        return false;    
    p->next = q->next;   
    if(q->next != NULL) 
        q->next->prior=p;  
    free(q);     
    return true;
}

// 销毁一个双链表
bool DestoryList(DLinklist &L){ 
    // 循环释放各个数据结点   
    while(L->next != NULL){    
        DeletNextDNode(L);      
        free(L);        
        // 头指针置空  
        L=NULL;     
    }
}

双链表的遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 向后遍历
while(p!=NULL){    
    // 对结点p做相应处理    
    p = p->next;
}

// 向前遍历
while(p!=NULL){    
    // 对结点p做相应处理 
    p = p->prior;
}

// 跳过头结点的遍历
while(p->prior!=NULL){ 
    //对结点p做相应处理    
    p = p->prior;
}

双链表不可随机存取，按位查找、按值查找操作都只能用遍历的方式实现。

四，循环链表

循环单链表的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
typedef struct LNode{           
    ElemType data;                  
    struct LNode *next; 
}DNode, *Linklist;

// 初始化循环单链表
bool InitList(LinkList &L){    
    L = (LNode *)malloc(sizeof(LNode));  
    if(L==NULL)             
        return false;    
    // 最后一个结点的next指针指向头结点    
    L->next = L;       
    return true;
}

// 判断循环单链表是否为空
bool Empty(LinkList L){    
    if(L->next == L)       
        return true;    
    else             
        return false;
}

// 判断结点p是否为循环单链表的表尾结点
bool isTail(LinkList L, LNode *p){ 
    if(p->next == L)          
        return true;      
    else            
        return false;
}

循环双链表的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
typedef struct DNode{            
    ElemType data;           
    struct DNode *prior, *next;  
}DNode, *DLinklist;

// 初始循环双链表
bool InitDLinkList(DLinklist &L){  
    L = (DNode *) malloc(sizeof(DNode));  
    if(L==NULL)            
        return false;    
    // 头结点的prior指针指向最后一个结点，最后一个结点的next指针指向头结点 
    L->prior = L;      
    L->next = L;
}

// 判断循环双链表是否为空
bool Empty(DLinklist L){   
    if(L->next == L)       
        return true;      
    else           
        return false;
}

// 判断结点p是否为循环双链表的表尾结点
bool isTail(DLinklist L, DNode *p){   
    if(p->next == L)        
        return true;     
    else            
        return false;
}

循环双链表的插入和删除操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 将结点s插入到结点p之后
bool InsertNextDNode(DNode *p, DNode *s){  
    s->next = p->next;   
    //循环双链表不用担心p结点的下一个结点为空   
    p->next->prior = s;  
    s->prior = p;     
    p->next = s;
}

// 删除p结点的后继结点
bool DeletNextDNode(DNode *p){  
    // 找到p的后继结点q       
    DNode *q =p->next;        
    //循环双链表不用担心q结点的下一个结点为空  
    p->next = q->next;    
    q->next->prior=p;    
    free(q);      
    return true;
}

参考自：https://blog.csdn.net/qq_55593227/article/details/123598044

考研408
数据结构之线性表代码
https://jimes.cn/2024/02/02/数据结构之线性表代码/
作者
Jimes
发布于
2024年2月2日
许可协议
\ No newline at end of file +数据结构之线性表代码 - 马锦的博客

数据结构之线性表代码

一，顺序表

1.1 顺序表的实现

静态实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#define MaxSize 10 // 定义最大长度 

typedef struct {
	int data[MaxSize]; // 使用静态的数组存放数据元素 
	int length; // 顺序表的当前长度 
}SqList;

// 初始化顺序表 
void InitList(SqList &L) {
	L.length = 0; // 顺序表初始长度为0 
}

int main() {
	SqList L; // 声明一个顺序表 
	InitList(L); // 初始化顺序表 
	return 0;
}

动态实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#define MaxSize 10 // 定义最大长度 
#define InitSize 10 // 顺序表的初始长度

typedef struct {
	int *data; // 声明动态分配数组的指针 
	int MaxSize; // 顺序表的最大容量
	int length; // 顺序表的当前长度 
}SeqList;

// 初始化顺序表 
void InitList(SeqList &L) {
	// 用malloc函数申请一片连续的存储空间 
	L.data = (int *)malloc(InitSize * sizeof(int));
	L.length = 0;
	L.MaxSize = InitSize;
}

// 增加动态数组的长度 ，非重点
void IncreaseSize(SeqList &L, int len) {
	int *p = L.data;
	L.data = (int *)malloc((L.MaxSize+len) * sizeof(int));
	for (int i = 0; i < L.length; i++)
		L.data[i] = p[i]; // 将数据复制到新区域 
	L.MaxSize = L.MaxSize + len; // 顺序表最大长度增加len 
	free(p); // 释放原来的内存空间 
}

int main() {
	SeqList L; // 声明一个顺序表 
	InitList(L); // 初始化顺序表 
    ...
	IncreaseSize(L, 5);
	return 0;
}

malloc() 函数的作用：会申请一片存储空间，并返回存储空间第一个位置的地址，也就是该位置的指针。

1.2 顺序表的基本操作

插入：

1
2
3
4
5
6
7
8
9
10
11
12
// 在顺序表i位置插入e
bool ListInsert(SqList &L, int i, int e) {
	if (i < 1 || i > L.length+1) // 判断i的范围是否有效 
		return false;
	if (L.length >= MaxSize) // 判断存储空间是否已满 
		return false;
	for (int j = L.length; j >= i; j--) // 将第i个元素之后的元素后移 
		L.data[j] = L.data[j-1];
	L.data[i-1] = e; // 在位置i处放入e 
	L.length++; // 长度+1 
	return true;
}

时间复杂度：

  • 最好时间复杂度：O ( 1 )
  • 最坏时间复杂度：O ( n )
  • 平均时间复杂度：O ( n )

删除：

1
2
3
4
5
6
7
8
9
10
// 删除顺序表i位置的数据并存入e
bool ListDelete(SqList &L, int i, int &e) {
	if (i < 1 || i > L.length) // 判断i的范围是否有效
		return false;
	e = L.data[i-1]; // 将被删除的元素赋值给e 
	for (int j = i; j < L.length; j++) //将第i个位置后的元素前移 
		L.data[j-1] = L.data[j];
	L.length--;
	return true; 
}

时间复杂度：

  • 最好时间复杂度：O ( 1 )
  • 最坏时间复杂度：O ( n )
  • 平均时间复杂度：O ( n )

按位查找：

1
2
3
4
5
6
// 静态分配的按位查找
#define MaxSize 10

ElemType GetElem(SqList L, int i) {
	return L.data[i-1];
}
1
2
3
4
5
6
// 动态分配的按位查找
#define InitSize 10

ElemType GetElem(SeqList L, int i) {
	return L.data[i-1];
}

时间复杂度： O ( 1 )

按值查找：

1
2
3
4
5
6
7
// 查找第一个元素值为e的元素，并返回其位序 
int LocateElem(SqList L, ElemType e) {
	for (int i = 0; i < L.length; i++)
		if (L.data[i] == e)
			return i+1; // 数组下标为i的元素值等于e，返回其位序i+1 
	return 0; // 没有查找到 
}

在《数据结构》考研初试中，手写代码可以直接用“==”，无论 ElemType 是基本数据类型还是结构类型

时间复杂度：

  • 最好时间复杂度：O ( 1 )
  • 最坏时间复杂度：O ( n )
  • 平均时间复杂度：O ( n )

二，单链表

2.1 单链表的实现

不带头结点的单链表：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

//初始化一个空的单链表
bool InitList(LinkList &L){
    L = NULL;//空表，暂时还没有任何结点
    return true;
}

void test(){
    LinkList L;//声明一个指向单链表的头指针
    //初始化一个空表
    InitList(L);
    ...
}

//判断单链表是否为空
bool Empty(LinkList L){
    return (L==NULL)
}

带头结点的单链表：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

// 初始化一个单链表（带头结点）
bool InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LNode));//分配一个头结点
    if (L == NULL)//内存不足，分配失败
    	return false;
    L->next = NULL;//头结点之后暂时还没有结点
    return true;
}

void test(){
    LinkList L;//声明一个指向单链表的头指针
    //初始化一个空表
    InitList(L);
    ...
}

//判断单链表是否为空
bool Empty(LinkList L){
    if (L->next == NULL)
        return true;
    else
        return false;
}

2.2 单链表的建立

尾插法建立单链表：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 使用尾插法建立单链表L
LinkList List_TailInsert(LinkList &L){
    int x;//设ElemType为整型int
    L = (LinkList)malloc(sizeof(LNode));//建立头结点(初始化空表)
    LNode *s, *r = L;//r为表尾指针
    scanf("%d", &x);//输入要插入的结点的值
    while(x!=9999){//输入9999表示结束
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        r = s;//r指针指向新的表尾结点
        scanf("%d", &x);
    }
    r->next = NULL;//尾结点指针置空
    return L;
}

时间复杂度：O ( n )

头插法建立单链表：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
LinkList List_HeadInsert(LinkList &L){//逆向建立单链表
    LNode *s;
    int x;
    L = (LinkList)malloc(sizeof(LNode));//建立头结点
    L->next = NULL;//初始为空链表,这步很关键
    scanf("%d", &x);//输入要插入的结点的值
    while(x!=9999){//输入9999表结束
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        s->next = L->next;
        L->next = s;
		//将新结点插入表中，L为头指针
		scanf("%d", &x);
    }
    return L;
}

头插法实现链表的逆置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 将链表L中的数据逆置并返回
LNode *Inverse(LNode *L){
    LNode *p, *q;
    p = L->next;//p指针指向第一个结点
    L->next = NULL;//头结点置空
    // 依次判断p结点中的数据并采用头插法插到L链表中
    while (p != NULL){
        q = p;
        p = p->next;
        q->next = L->next;
        L->next = q;
    }
    return L;
}

2.3 单链表的基本操作

按位序插入（带头结点）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

//在第i个位置插入元素e
bool ListInsert(LinkList &L, int i, ElemType e){
    if(i<1)
        return False;
    LNode *p; //指针p指向当前扫描到的结点
    int j=0;  //当前p指向的是第几个结点
    p = L;    //循环找到第i-1个结点
    while(p!=NULL && j<i-1){ //如果i>lengh，p最后会等于NULL
        p = p->next;
        j++;
    }
	//p值为NULL说明i值不合法
    if (p==NULL)
        return false;
	//在第i-1个结点后插入新结点
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
	//将结点s连到p后
    return true;
}

时间复杂度：

  • 最好时间复杂度：O ( 1 )
  • 最坏时间复杂度：O ( n )
  • 平均时间复杂度：O ( n )

按位序插入（不带头结点）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

//在第i个位置插入元素e
bool ListInsert(LinkList &L, int i, ElemType e){
	//判断i的合法性
    if(i<1)
        return false;
	//需要判断插入的位置是否是第1个
    if(i==1){
        LNode *s = (LNode *)malloc(size of(LNode));
        s->data =e;
        s->next =L;
        L=s;//头指针指向新结点
        return true;
    }
	//i>1的情况与带头结点一样，唯一区别是j的初始值为1
    LNode *p;//指针p指向当前扫描到的结点
    int j=1;//当前p指向的是第几个结点
    p = L;
	//循环找到第i-1个结点
    while(p!=NULL && j<i-1){//如果i>lengh，p最后会等于NULL
        p = p->next;
        j++;
    }
	//p值为NULL说明i值不合法
    if (p==NULL)
        return false;
	//在第i-1个结点后插入新结点
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

时间复杂度：

  • 最好时间复杂度：O ( 1 )
  • 最坏时间复杂度：O ( n )
  • 平均时间复杂度：O ( n )

除非特别声明，否则之后的代码都默认为带头结点

指定结点的后插操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

// 在结点p后插入元素e
bool InsertNextNode(LNode *p, ElemType e){
    if(p==NULL){
        return false;
    }
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if(s==NULL)
        return false;
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

// 按位序插入的函数中可以直接调用后插操作
bool ListInsert(LinkList &L, int i, ElemType e){
    if(i<1)
        return False;
    LNode *p;
	//指针p指向当前扫描到的结点
	int j=0;
	//当前p指向的是第几个结点
    p = L;
	//循环找到第i-1个结点
    while(p!=NULL && j<i-1){
	//如果i>lengh, p最后会等于NULL
        p = p->next;
        j++;
    }
    return InsertNextNode(p, e)
}

时间复杂度：O ( 1 )

指定结点的前插操作：

如果传入头指针，就可以循环整个链表找到指定结点p的前驱结点q，再对q进行后插操作；
如果不传入头指针，可以在指定结点p后插入一个结点s，并交换两个结点所保存的数据，从而变相实现指定结点的前插操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

// 在结点p前插入元素e
bool InsertPriorNode(LNode *p, ElemType e){
    if(p==NULL)
        return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
	// 内存不足分配失败
	if(s==NULL)
        return false;
	// 将s插入结点p之后
    s->next = p->next;
    p->next = s;
	// 交换两个结点中的数据
    s->data = p->data;
    p->data = e;
    return true;
}

时间复杂度：O ( 1 )

按位序删除：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
typedef struct LNode{
    ElemType data;
    struct LNode *next;}LNode, *LinkList;

// 删除第i个结点并将其所保存的数据存入e
bool ListDelete(LinkList &L, int i, ElemType &e){
    if(i<1)
        return false;
    LNode *p;//指针p指向当前扫描到的结点
    int j=0;//当前p指向的是第几个结点
    p = L;
	//循环找到第i-1个结点
    while(p!=NULL && j<i-1){
	//如果i>lengh，p和p的后继结点会等于NULL
        p = p->next;
        j++;
    }
    if(p==NULL)
        return false;
    if(p->next == NULL)
        return false;
//令q暂时保存被删除的结点
    LNode *q = p->next;
    e = q->data;
    p->next = q->next;
    free(q)
    return true;
}

时间复杂度：

  • 最好时间复杂度：O ( 1 )
  • 最坏时间复杂度：O ( n )
  • 平均时间复杂度：O ( n )

删除指定结点：

如果传入头指针，就可以循环整个链表找到指定结点p的前驱结点q，再对p进行删除操作；
如果不传入头指针，可以把指定结点p的后继结点q删除，并使结点p保存结点q存储的数据，从而变相实现删除指定结点的操作。但是如果指定结点p没有后继结点，这么做会报错。

1
2
3
4
5
6
7
8
9
10
// 删除指定结点p
bool DeleteNode(LNode *p){
    if(p==NULL)
        return false;
    LNode *q = p->next;// 令q指向p的后继结点// 如果p是最后一个结点，则q指向NULL，继续执行就会报错
    p->data = q->data;
    p->next = q->next;
    free(q);
    return true;
}

时间复杂度：O ( 1 )

按位查找：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

// 查找指定位序i的结点并返回
LNode * GetElem(LinkList L, int i){
    if(i<0)
        return NULL;
    LNode *p;
    int j=0;
    p = L;
    while(p!=NULL && j<i){
        p = p->next;
        j++;
    }
    return p;
}

// 封装后的插入操作，在第i个位置插入元素e，可以调用查询操作和后插操作
bool ListInsert(LinkList &L, int i, ElemType e){
    if(i<1)
        return False;
	// 找到第i-1个元素
    LNode *p = GetElem(L, i-1);
	// 在p结点后插入元素e
	return InsertNextNode(p, e)
}

时间复杂度：

  • 最好时间复杂度：O ( 1 )
  • 最坏时间复杂度：O ( n )
  • 平均时间复杂度：O ( n )

按值查找：

1
2
3
4
5
6
7
8
9
// 查找数据域为e的结点指针，否则返回NULL
LNode * LocateElem(LinkList L, ElemType e){
    LNode *P = L->next;
    // 从第一个结点开始查找数据域为e的结点
    while(p!=NULL && p->data != e){
        p = p->next;
    }
    return p;
}

时间复杂度：

  • 最好时间复杂度：O ( 1 )
  • 最坏时间复杂度：O ( n )
  • 平均时间复杂度：O ( n )

计算单链表长度：

1
2
3
4
5
6
7
8
9
10
// 计算单链表的长度
int Length(LinkList L){
    int len=0;//统计表长
    LNode *p = L;
    while(p->next != NULL){
        p = p->next;
        len++;
    }
    return len;
}

时间复杂度：O ( n )

三，双链表

双链表的初始化 (带头结点)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
typedef struct DNode{            //定义双链表结点类型
    ElemType data;               //数据域
    struct DNode *prior, *next;  //前驱和后继指针
}DNode, *DLinklist;

// 初始化双链表
bool InitDLinkList(Dlinklist &L){
    L = (DNode *)malloc(sizeof(DNode));
    if(L==NULL)
        return false;
    L->prior = NULL;//头结点的prior指针永远指向NULL
    L->next = NULL;//头结点之后暂时还没有结点，置空
    return true;
}

void testDLinkList(){
    DLinklist L;
    InitDLinkList(L);
    ...
}

// 判断双链表是否为空
bool Empty(DLinklist L){
    if(L->next == NULL)
        return true;
    else
        return false;
}

双链表的后插操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
typedef struct DNode{
    ElemType data;
    struct DNode *prior, *next;
}DNode, *DLinklist;

// 将结点s插入到结点p之后
bool InsertNextDNode(DNode *p, DNode *s){ 
    if(p==NULL || s==NULL)  
        return false;         
    s->next = p->next;      
    // 判断结点p之后是否有后继结点  
    if (p->next != NULL)   
        p->next->prior = s; 
    s->prior = p;   
    p->next = s;     
    return true;
}

双链表的前插操作、按位序插入操作都可以转换成后插操作

双链表的删除操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// 删除p结点的后继结点
bool DeletNextDNode(DNode *p){   
    if(p==NULL)           
        return false;   
    // 找到p的后继结点q    
    DNode *q =p->next;   
    if(q==NULL)          
        return false;    
    p->next = q->next;   
    if(q->next != NULL) 
        q->next->prior=p;  
    free(q);     
    return true;
}

// 销毁一个双链表
bool DestoryList(DLinklist &L){ 
    // 循环释放各个数据结点   
    while(L->next != NULL){    
        DeletNextDNode(L);      
        free(L);        
        // 头指针置空  
        L=NULL;     
    }
}

双链表的遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 向后遍历
while(p!=NULL){    
    // 对结点p做相应处理    
    p = p->next;
}

// 向前遍历
while(p!=NULL){    
    // 对结点p做相应处理 
    p = p->prior;
}

// 跳过头结点的遍历
while(p->prior!=NULL){ 
    //对结点p做相应处理    
    p = p->prior;
}

双链表不可随机存取，按位查找、按值查找操作都只能用遍历的方式实现。

四，循环链表

循环单链表的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
typedef struct LNode{           
    ElemType data;                  
    struct LNode *next; 
}DNode, *Linklist;

// 初始化循环单链表
bool InitList(LinkList &L){    
    L = (LNode *)malloc(sizeof(LNode));  
    if(L==NULL)             
        return false;    
    // 最后一个结点的next指针指向头结点    
    L->next = L;       
    return true;
}

// 判断循环单链表是否为空
bool Empty(LinkList L){    
    if(L->next == L)       
        return true;    
    else             
        return false;
}

// 判断结点p是否为循环单链表的表尾结点
bool isTail(LinkList L, LNode *p){ 
    if(p->next == L)          
        return true;      
    else            
        return false;
}

循环双链表的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
typedef struct DNode{            
    ElemType data;           
    struct DNode *prior, *next;  
}DNode, *DLinklist;

// 初始循环双链表
bool InitDLinkList(DLinklist &L){  
    L = (DNode *) malloc(sizeof(DNode));  
    if(L==NULL)            
        return false;    
    // 头结点的prior指针指向最后一个结点，最后一个结点的next指针指向头结点 
    L->prior = L;      
    L->next = L;
}

// 判断循环双链表是否为空
bool Empty(DLinklist L){   
    if(L->next == L)       
        return true;      
    else           
        return false;
}

// 判断结点p是否为循环双链表的表尾结点
bool isTail(DLinklist L, DNode *p){   
    if(p->next == L)        
        return true;     
    else            
        return false;
}

循环双链表的插入和删除操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 将结点s插入到结点p之后
bool InsertNextDNode(DNode *p, DNode *s){  
    s->next = p->next;   
    //循环双链表不用担心p结点的下一个结点为空   
    p->next->prior = s;  
    s->prior = p;     
    p->next = s;
}

// 删除p结点的后继结点
bool DeletNextDNode(DNode *p){  
    // 找到p的后继结点q       
    DNode *q =p->next;        
    //循环双链表不用担心q结点的下一个结点为空  
    p->next = q->next;    
    q->next->prior=p;    
    free(q);      
    return true;
}

参考自：https://blog.csdn.net/qq_55593227/article/details/123598044

考研408
数据结构之线性表代码
https://jimes.cn/2024/02/02/数据结构之线性表代码/
作者
Jimes
发布于
2024年2月2日
许可协议
+ + \ No newline at end of file diff --git "a/2024/02/03/\346\225\260\346\215\256\347\273\223\346\236\204\344\271\213\346\240\210\344\270\216\351\230\237\345\210\227\344\273\243\347\240\201/index.html" "b/2024/02/03/\346\225\260\346\215\256\347\273\223\346\236\204\344\271\213\346\240\210\344\270\216\351\230\237\345\210\227\344\273\243\347\240\201/index.html" index 0086236..fec9fb5 100644 --- "a/2024/02/03/\346\225\260\346\215\256\347\273\223\346\236\204\344\271\213\346\240\210\344\270\216\351\230\237\345\210\227\344\273\243\347\240\201/index.html" +++ "b/2024/02/03/\346\225\260\346\215\256\347\273\223\346\236\204\344\271\213\346\240\210\344\270\216\351\230\237\345\210\227\344\273\243\347\240\201/index.html" @@ -1 +1,14 @@ -数据结构之栈与队列代码 - 马锦的博客

数据结构之栈与队列代码

一，顺序栈

顺序栈的定义：

1
2
3
4
5
#define MaxSize 10           //定义栈中元素的最大个数
typedef struct{
    ElemType data[MaxSize];  //静态数组存放栈中元素
    int top;                 //栈顶元素
}SqStack;

顺序栈的初始化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#define MaxSize 10
typedef struct{
    ElemType data[MaxSize];
    int top;
}SqStack;

// 初始化栈
void InitStack(SqStack &S){
    S.top = -1;//初始化栈顶指针
}

// 判断栈是否为空
bool StackEmpty(SqStack S){
    if(S.top == -1)
        return true;
    else
        return false;
}

入栈出栈：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 新元素进栈
bool Push(SqStack &S, ElemType x){
    // 判断栈是否已满
    if(S.top == MaxSize - 1)
        return false;
    S.data[++S.top] = x;
    return true;
}

// 出栈
bool Pop(SqStack &x, ElemType &x){
    // 判断栈是否为空
    if(S.top == -1)
        return false;
    x = S.data[S.top--];
    return true;
}

读取栈顶元素：

1
2
3
4
5
6
7
// 读栈顶元素
bool GetTop(SqStack S, ElemType &x){
    if(S.top == -1)
        return false;
    x = S.data[S.top];
    return true;
}

共享栈（两个栈共享同一片空间）：

1
2
3
4
5
6
7
8
9
10
11
12
#define MaxSize 10      //定义栈中元素的最大个数
typedef struct{
    ElemType data[MaxSize];//静态数组存放栈中元素
    int top0;                        //0号栈栈顶指针
    int top1;                       //1号栈栈顶指针
}ShStack;

// 初始化栈
void InitSqStack(ShStack &S){
    S.top0 = -1;
    S.top1 = MaxSize;
}

二，链栈

链栈的定义：

1
2
3
4
5
6
7
8
typedef struct Linknode{
    ElemType data;//数据域
    Linknode *next;//指针域
}Linknode,*LiStack;

void testStack(){
    LiStack L;//声明一个链栈
}

链栈的初始化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
typedef struct Linknode{
    ElemType data;
    Linknode *next;
}Linknode,*LiStack;

// 初始化栈
bool InitStack(LiStack &L){
    L = (Linknode *)malloc(sizeof(Linknode));
    if(L == NULL)
        return false;
    L->next = NULL;
    return true;
}

// 判断栈是否为空
bool isEmpty(LiStack &L){
    if(L->next == NULL)
        return true;
    else
        return false;
}

入栈出栈：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 新元素入栈
bool pushStack(LiStack &L,ElemType x){
    Linknode *s = (Linknode *)malloc(sizeof(Linknode));
    if(s == NULL)
        return false;
    s->data = x;
    // 头插法
    s->next = L->next;
    L->next = s;
    return true;
}

// 出栈
bool popStack(LiStack &L, int &x){
    // 栈空不能出栈
    if(L->next == NULL)
        return false;
    Linknode *s = L->next;
    x = s->data;
    L->next = s->next;
    free(s);
    return true;
}

三，顺序队列

顺序队列的定义：

1
2
3
4
5
6
7
8
9
#define MaxSize 10;//定义队列中元素的最大个数
typedef struct{
    ElemType data[MaxSize];//用静态数组存放队列元素
    int front, rear;                //队头指针和队尾指针
}SqQueue;

void test{
    SqQueue Q;//声明一个队列
}

顺序队列的初始化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#define MaxSize 10;
typedef struct{
    ElemType data[MaxSize];
    int front, rear;
}SqQueue;

// 初始化队列
void InitQueue(SqQueue &Q){
    // 初始化时，队头、队尾指针指向0
    // 队尾指针指向的是即将插入数据的数组下标
    // 队头指针指向的是队头元素的数组下标
    Q.rear = Q.front = 0;
}

// 判断队列是否为空
bool QueueEmpty(SqQueue Q){
    if(Q.rear == Q.front)
        return true;
    else
        return false;
}

入队出队（循环队列）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 新元素入队
bool EnQueue(SqQueue &Q, ElemType x){
    // 如果队列已满直接返回
    if((Q.rear+1)%MaxSize == Q.front)//牺牲一个单元区分队空和队满
	return false;
    Q.data[Q.rear] = x;
    Q.rear = (Q.rear+1)%MaxSize;
    return true;
}

// 出队
bool DeQueue(SqQueue &Q, ElemType &x){
    // 如果队列为空直接返回
    if(Q.rear == Q.front)
        return false;
    x = Q.data[Q.front];
    Q.front = (Q.front+1)%MaxSize;
    return true;
}

获得队头元素：

1
2
3
4
5
6
7
// 获取队头元素并存入x
bool GetHead(SqQueue &Q, ElemType &x){
    if(Q.rear == Q.front)
        return false;
    x = Q.data[Q.front];
    return true;
}

四，链队列

链队列的定义：

1
2
3
4
5
6
7
8
9
10
11
// 链式队列结点
typedef struct LinkNode{
    ElemType data;
    struct LinkNode *next;
}

// 链式队列
typedef struct{
    // 头指针和尾指针
    LinkNode *front, *rear;
}LinkQueue;

链队列的初始化（带头结点）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
typedef struct LinkNode{
    ElemType data;
    struct LinkNode *next;
}LinkNode;

typedef struct{
    LinkNode *front, *rear;
}LinkQueue;

// 初始化队列
void InitQueue(LinkQueue &Q){
    // 初始化时，front、rear都指向头结点
    Q.front = Q.rear = (LinkNode *)malloc(sizeof(LinkNode));
    Q.front -> next = NULL;
}

// 判断队列是否为空
bool IsEmpty(LinkQueue Q){
    if(Q.front == Q.rear)
        return true;
    else
        return false;
}

入队出队：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 新元素入队
void EnQueue(LinkQueue &Q, ElemType x){
    LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode));
    s->data = x;
    s->next = NULL;
    Q.rear->next = s;
    Q.rear = s;
}

// 队头元素出队
bool DeQueue(LinkQueue &Q, ElemType &x){
    if(Q.front == Q.rear)
        return false;
    LinkNode *p = Q.front->next;
    x = p->data;
    Q.front->next = p->next;
    // 如果p是最后一个结点，则将队头指针也指向NULL
    if(Q.rear == p)
        Q.rear = Q.front;
    free(p);
    return true;
}

以上是带头结点的链队列，下面是不带头结点的操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
typedef struct LinkNode{
    ElemType data;
    struct LinkNode *next;
}LinkNode;

typedef struct{
    LinkNode *front, *rear;
}LinkQueue;

// 初始化队列
void InitQueue(LinkQueue &Q){
    // 不带头结点的链队列初始化，头指针和尾指针都指向NULL
    Q.front = NULL;
    Q.rear = NULL;
}

// 判断队列是否为空
bool IsEmpty(LinkQueue Q){
    if(Q.front == NULL)
        return true;
    else
        return false;
}

// 新元素入队
void EnQueue(LinkQueue &Q, ElemType x){
    LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode));
    s->data = x;
    s->next = NULL;
    // 第一个元素入队时需要特别处理
    if(Q.front == NULL){
        Q.front = s;
        Q.rear = s;
    }else{
        Q.rear->next = s;
        Q.rear = s;
    }
}

//队头元素出队
bool DeQueue(LinkQueue &Q, ElemType &x){
    if(Q.front == NULL)
        return false;
    LinkNode *s = Q.front;
    x = s->data;
    if(Q.front == Q.rear){
        Q.front = Q.rear = NULL;
    }else{
        Q.front = Q.front->next;
    }
    free(s);
    return true;
}

参考自：https://blog.csdn.net/qq_55593227/article/details/123598044

考研408
数据结构之栈与队列代码
https://jimes.cn/2024/02/03/数据结构之栈与队列代码/
作者
Jimes
发布于
2024年2月3日
许可协议
\ No newline at end of file +数据结构之栈与队列代码 - 马锦的博客

数据结构之栈与队列代码

一，顺序栈

顺序栈的定义：

1
2
3
4
5
#define MaxSize 10           //定义栈中元素的最大个数
typedef struct{
    ElemType data[MaxSize];  //静态数组存放栈中元素
    int top;                 //栈顶元素
}SqStack;

顺序栈的初始化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#define MaxSize 10
typedef struct{
    ElemType data[MaxSize];
    int top;
}SqStack;

// 初始化栈
void InitStack(SqStack &S){
    S.top = -1;//初始化栈顶指针
}

// 判断栈是否为空
bool StackEmpty(SqStack S){
    if(S.top == -1)
        return true;
    else
        return false;
}

入栈出栈：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 新元素进栈
bool Push(SqStack &S, ElemType x){
    // 判断栈是否已满
    if(S.top == MaxSize - 1)
        return false;
    S.data[++S.top] = x;
    return true;
}

// 出栈
bool Pop(SqStack &x, ElemType &x){
    // 判断栈是否为空
    if(S.top == -1)
        return false;
    x = S.data[S.top--];
    return true;
}

读取栈顶元素：

1
2
3
4
5
6
7
// 读栈顶元素
bool GetTop(SqStack S, ElemType &x){
    if(S.top == -1)
        return false;
    x = S.data[S.top];
    return true;
}

共享栈（两个栈共享同一片空间）：

1
2
3
4
5
6
7
8
9
10
11
12
#define MaxSize 10      //定义栈中元素的最大个数
typedef struct{
    ElemType data[MaxSize];//静态数组存放栈中元素
    int top0;                        //0号栈栈顶指针
    int top1;                       //1号栈栈顶指针
}ShStack;

// 初始化栈
void InitSqStack(ShStack &S){
    S.top0 = -1;
    S.top1 = MaxSize;
}

二，链栈

链栈的定义：

1
2
3
4
5
6
7
8
typedef struct Linknode{
    ElemType data;//数据域
    Linknode *next;//指针域
}Linknode,*LiStack;

void testStack(){
    LiStack L;//声明一个链栈
}

链栈的初始化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
typedef struct Linknode{
    ElemType data;
    Linknode *next;
}Linknode,*LiStack;

// 初始化栈
bool InitStack(LiStack &L){
    L = (Linknode *)malloc(sizeof(Linknode));
    if(L == NULL)
        return false;
    L->next = NULL;
    return true;
}

// 判断栈是否为空
bool isEmpty(LiStack &L){
    if(L->next == NULL)
        return true;
    else
        return false;
}

入栈出栈：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 新元素入栈
bool pushStack(LiStack &L,ElemType x){
    Linknode *s = (Linknode *)malloc(sizeof(Linknode));
    if(s == NULL)
        return false;
    s->data = x;
    // 头插法
    s->next = L->next;
    L->next = s;
    return true;
}

// 出栈
bool popStack(LiStack &L, int &x){
    // 栈空不能出栈
    if(L->next == NULL)
        return false;
    Linknode *s = L->next;
    x = s->data;
    L->next = s->next;
    free(s);
    return true;
}

三，顺序队列

顺序队列的定义：

1
2
3
4
5
6
7
8
9
#define MaxSize 10;//定义队列中元素的最大个数
typedef struct{
    ElemType data[MaxSize];//用静态数组存放队列元素
    int front, rear;                //队头指针和队尾指针
}SqQueue;

void test{
    SqQueue Q;//声明一个队列
}

顺序队列的初始化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#define MaxSize 10;
typedef struct{
    ElemType data[MaxSize];
    int front, rear;
}SqQueue;

// 初始化队列
void InitQueue(SqQueue &Q){
    // 初始化时，队头、队尾指针指向0
    // 队尾指针指向的是即将插入数据的数组下标
    // 队头指针指向的是队头元素的数组下标
    Q.rear = Q.front = 0;
}

// 判断队列是否为空
bool QueueEmpty(SqQueue Q){
    if(Q.rear == Q.front)
        return true;
    else
        return false;
}

入队出队（循环队列）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 新元素入队
bool EnQueue(SqQueue &Q, ElemType x){
    // 如果队列已满直接返回
    if((Q.rear+1)%MaxSize == Q.front)//牺牲一个单元区分队空和队满
	return false;
    Q.data[Q.rear] = x;
    Q.rear = (Q.rear+1)%MaxSize;
    return true;
}

// 出队
bool DeQueue(SqQueue &Q, ElemType &x){
    // 如果队列为空直接返回
    if(Q.rear == Q.front)
        return false;
    x = Q.data[Q.front];
    Q.front = (Q.front+1)%MaxSize;
    return true;
}

获得队头元素：

1
2
3
4
5
6
7
// 获取队头元素并存入x
bool GetHead(SqQueue &Q, ElemType &x){
    if(Q.rear == Q.front)
        return false;
    x = Q.data[Q.front];
    return true;
}

四，链队列

链队列的定义：

1
2
3
4
5
6
7
8
9
10
11
// 链式队列结点
typedef struct LinkNode{
    ElemType data;
    struct LinkNode *next;
}

// 链式队列
typedef struct{
    // 头指针和尾指针
    LinkNode *front, *rear;
}LinkQueue;

链队列的初始化（带头结点）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
typedef struct LinkNode{
    ElemType data;
    struct LinkNode *next;
}LinkNode;

typedef struct{
    LinkNode *front, *rear;
}LinkQueue;

// 初始化队列
void InitQueue(LinkQueue &Q){
    // 初始化时，front、rear都指向头结点
    Q.front = Q.rear = (LinkNode *)malloc(sizeof(LinkNode));
    Q.front -> next = NULL;
}

// 判断队列是否为空
bool IsEmpty(LinkQueue Q){
    if(Q.front == Q.rear)
        return true;
    else
        return false;
}

入队出队：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 新元素入队
void EnQueue(LinkQueue &Q, ElemType x){
    LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode));
    s->data = x;
    s->next = NULL;
    Q.rear->next = s;
    Q.rear = s;
}

// 队头元素出队
bool DeQueue(LinkQueue &Q, ElemType &x){
    if(Q.front == Q.rear)
        return false;
    LinkNode *p = Q.front->next;
    x = p->data;
    Q.front->next = p->next;
    // 如果p是最后一个结点，则将队头指针也指向NULL
    if(Q.rear == p)
        Q.rear = Q.front;
    free(p);
    return true;
}

以上是带头结点的链队列，下面是不带头结点的操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
typedef struct LinkNode{
    ElemType data;
    struct LinkNode *next;
}LinkNode;

typedef struct{
    LinkNode *front, *rear;
}LinkQueue;

// 初始化队列
void InitQueue(LinkQueue &Q){
    // 不带头结点的链队列初始化，头指针和尾指针都指向NULL
    Q.front = NULL;
    Q.rear = NULL;
}

// 判断队列是否为空
bool IsEmpty(LinkQueue Q){
    if(Q.front == NULL)
        return true;
    else
        return false;
}

// 新元素入队
void EnQueue(LinkQueue &Q, ElemType x){
    LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode));
    s->data = x;
    s->next = NULL;
    // 第一个元素入队时需要特别处理
    if(Q.front == NULL){
        Q.front = s;
        Q.rear = s;
    }else{
        Q.rear->next = s;
        Q.rear = s;
    }
}

//队头元素出队
bool DeQueue(LinkQueue &Q, ElemType &x){
    if(Q.front == NULL)
        return false;
    LinkNode *s = Q.front;
    x = s->data;
    if(Q.front == Q.rear){
        Q.front = Q.rear = NULL;
    }else{
        Q.front = Q.front->next;
    }
    free(s);
    return true;
}

参考自：https://blog.csdn.net/qq_55593227/article/details/123598044

考研408
数据结构之栈与队列代码
https://jimes.cn/2024/02/03/数据结构之栈与队列代码/
作者
Jimes
发布于
2024年2月3日
许可协议
+ + \ No newline at end of file diff --git "a/2024/07/21/\347\224\237\346\255\273\347\213\231\345\207\2732\345\207\200\345\214\226\350\241\214\345\212\250\346\214\202\346\234\272\350\204\232\346\234\254/index.html" "b/2024/07/21/\347\224\237\346\255\273\347\213\231\345\207\2732\345\207\200\345\214\226\350\241\214\345\212\250\346\214\202\346\234\272\350\204\232\346\234\254/index.html" index f2ffa71..1b299b9 100644 --- "a/2024/07/21/\347\224\237\346\255\273\347\213\231\345\207\2732\345\207\200\345\214\226\350\241\214\345\212\250\346\214\202\346\234\272\350\204\232\346\234\254/index.html" +++ "b/2024/07/21/\347\224\237\346\255\273\347\213\231\345\207\2732\345\207\200\345\214\226\350\241\214\345\212\250\346\214\202\346\234\272\350\204\232\346\234\254/index.html" @@ -1 +1,14 @@ -生死狙击2净化行动挂机脚本 - 马锦的博客

生死狙击2净化行动挂机脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
import pyautogui
import pydirectinput
import time
import os
import sys
pyautogui.PAUSE = 0
#适用于净化行动，关闭自动匹配队友，开启单人匹配，在开始匹配页面运行程序。
#########   以管理员身份运行！！！！    ###########
# 获取图片的绝对路径
def get_resource_path(relative_path):
    if hasattr(sys, '_MEIPASS'):
        return os.path.join(sys._MEIPASS, relative_path)
    return os.path.join(os.path.abspath("."), relative_path)
#局内动作循环
def repeat_keys(keys):
    try:
        a = time.time()
        bb = time.time()
        while a-bb+5000>0:
            for key in keys:
                pyautogui.keyDown(key)
                time.sleep(1)
                pyautogui.keyUp(key)
                time.sleep(9)
                bb = time.time()
        pyautogui.press('esc')
    except KeyboardInterrupt:
        print("Stopped by user")
#检测图片
def identify_picture(a):
    left, top, width, height = pyautogui.locateOnScreen(get_resource_path(a),confidence=0.9,grayscale=True)   # 寻找图片
    center = pyautogui.center((left, top, width, height))    # 寻找图片的中心
    print('开始',center)
    pydirectinput.moveTo(center[0],center[1])
    pydirectinput.click()
    time.sleep(10)
# 4：3比例 + 无边框窗口
while True:
    try:
        identify_picture('img\sta1.png') #检测开始匹配
    except TypeError:
        try:
            identify_picture('img\\bac.png') #检测返回大厅
        except TypeError:
            try:
                identify_picture('img\\img.png') #检测准备完毕
                repeat_keys(['w', 'a', 's', 'd']) #局内动作，防止强退
            except TypeError:
                try:
                    identify_picture('img\\img_1.png') #检测返回大厅（出错情况）
                except TypeError:
                    try:
                        identify_picture('img\\img_2.png') #检测确定（出错情况）
                    except TypeError:
                        try:
                            identify_picture('img\\img_3.png') #检测点击空白处关闭（出错情况）
                        except TypeError:
                            print('无')
                            time.sleep(2)
游戏 > 自动化
生死狙击2净化行动挂机脚本
https://jimes.cn/2024/07/21/生死狙击2净化行动挂机脚本/
作者
Jimes
发布于
2024年7月21日
许可协议
\ No newline at end of file +生死狙击2净化行动挂机脚本 - 马锦的博客

生死狙击2净化行动挂机脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
import pyautogui
import pydirectinput
import time
import os
import sys
pyautogui.PAUSE = 0
#适用于净化行动，关闭自动匹配队友，开启单人匹配，在开始匹配页面运行程序。
#########   以管理员身份运行！！！！    ###########
# 获取图片的绝对路径
def get_resource_path(relative_path):
    if hasattr(sys, '_MEIPASS'):
        return os.path.join(sys._MEIPASS, relative_path)
    return os.path.join(os.path.abspath("."), relative_path)
#局内动作循环
def repeat_keys(keys):
    try:
        a = time.time()
        bb = time.time()
        while a-bb+5000>0:
            for key in keys:
                pyautogui.keyDown(key)
                time.sleep(1)
                pyautogui.keyUp(key)
                time.sleep(9)
                bb = time.time()
        pyautogui.press('esc')
    except KeyboardInterrupt:
        print("Stopped by user")
#检测图片
def identify_picture(a):
    left, top, width, height = pyautogui.locateOnScreen(get_resource_path(a),confidence=0.9,grayscale=True)   # 寻找图片
    center = pyautogui.center((left, top, width, height))    # 寻找图片的中心
    print('开始',center)
    pydirectinput.moveTo(center[0],center[1])
    pydirectinput.click()
    time.sleep(10)
# 4：3比例 + 无边框窗口
while True:
    try:
        identify_picture('img\sta1.png') #检测开始匹配
    except TypeError:
        try:
            identify_picture('img\\bac.png') #检测返回大厅
        except TypeError:
            try:
                identify_picture('img\\img.png') #检测准备完毕
                repeat_keys(['w', 'a', 's', 'd']) #局内动作，防止强退
            except TypeError:
                try:
                    identify_picture('img\\img_1.png') #检测返回大厅（出错情况）
                except TypeError:
                    try:
                        identify_picture('img\\img_2.png') #检测确定（出错情况）
                    except TypeError:
                        try:
                            identify_picture('img\\img_3.png') #检测点击空白处关闭（出错情况）
                        except TypeError:
                            print('无')
                            time.sleep(2)
游戏 > 自动化
生死狙击2净化行动挂机脚本
https://jimes.cn/2024/07/21/生死狙击2净化行动挂机脚本/
作者
Jimes
发布于
2024年7月21日
许可协议
+ + \ No newline at end of file diff --git "a/2024/09/11/ARIMA\351\242\204\346\265\213/index.html" "b/2024/09/11/ARIMA\351\242\204\346\265\213/index.html" index 3bce64a..b2f5713 100644 --- "a/2024/09/11/ARIMA\351\242\204\346\265\213/index.html" +++ "b/2024/09/11/ARIMA\351\242\204\346\265\213/index.html" @@ -1 +1,14 @@ -ARIMA预测代码 - 马锦的博客

ARIMA预测代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
import copy
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import statsmodels.api as sm
from statsmodels.stats.diagnostic import acorr_ljungbox
from statsmodels.graphics.tsaplots import plot_pacf,plot_acf
import warnings
from math import log
from sklearn.metrics import mean_squared_error
warnings.filterwarnings("ignore")
plt.rcParams['axes.unicode_minus'] = False #显示负号
plt.rcParams['font.family'] = ['sans-serif']
plt.rcParams['font.sans-serif'] = ['SimHei']  # 散点图标签可以显示中文

data = pd.read_csv('时间序列预测数据集.csv',parse_dates=['Date'])
data.set_index('Date',inplace=True)     #将时间设置为行索引

####################################   绘制时序图   ############################################
def picture(data):
    plt.figure(figsize=(16,16))
    for i in range(1,5):
        plt.subplot(4,1,i)
        df = data[f"198{1+2*(i-1)}-01-01":f"198{3+2*(i-1)}-01-01"]
        plt.plot(df.index,df['Temp'].values)
        plt.xticks(rotation=45,size=6)
        if i == 1:
            plt.title("时序图")
    plt.show()
    plt.close()
######################################   时间序列检验      #######################################
def inspect(data):
    # 单位根检验-ADF检验
    ADF = sm.tsa.stattools.adfuller(data['Temp'])
    print('ADF值:', format(ADF[0], '.4f'))
    print('拒绝程度值:', ADF[4])      #ADF值需要小于三个拒绝程度值

    # 白噪声检验
    white_noise = acorr_ljungbox(data['Temp'], lags = [6, 12, 24],boxpierce=True) #lag是需要检验的阶数
    print('白噪声检验:\n',white_noise)   #LB和BP统计量的P值都小于显著水平（α = 0.05）,所以拒绝序列为纯随机序列的原假设，认为该序列为非白噪声序列

    fig = plt.figure(figsize=(16,6))

    ax1 = fig.add_subplot(1,2,1)
    plot_acf(data['Temp'],ax=ax1)
    plt.title("自相关图")        #需要拖尾

    ax2 = fig.add_subplot(1,2,2)
    plot_pacf(data['Temp'],ax=ax2)
    plt.title("偏自相关图")      #需要截尾,确定p

    plt.show()
    plt.close()
#####################################    信息准则    ###########################################
def information(df,df0,p):
    n = len(df)
    mse = mean_squared_error(df,df0)
    #aic = n * log(mse) + 2 * p
    aicc = log(mse) + (n+p)/(n-p-2)
    bic = n * log(mse) + p * log(n)
    return aicc,bic
def AR_prediction(x, p, predict_x_n = 0):
    df = np.array(x).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
    df0 = df.copy()         #准备一个副本，为了存储预测的数据
    Y = df[p:].copy()
    h = len(df0)-p
    X = np.zeros((h,p+1))
    for i in range(h):            #得到X矩阵
        X[i][0] = 1
        for v in range(1,p+1):
            X[i,-v] = df[i+v-1]
    sigma = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(Y.T)          #最小二乘法估计参数值
    for i in range(h):
        df0[p+i] = sum(sigma * X[i])      #得到所有预测的估计值
    df00 = df.copy()
    df1 = np.zeros(predict_x_n)
    for i in range(predict_x_n):
        df1[i] = sum(sigma[1:] * df00[-p:][::-1])+sigma[0]        #得到所有预测值
        df00 = np.append(df00,df1[i])
    return df0,df1

#########################################   阶数确定   ##############################################
def p_finally(n):
    jieguo = []
    for i in range(1,n):
        df0,df1 = AR_prediction(data,i)
        aicc,bic = information(data,df0,i)
        jieguo.append([i,aicc,bic])
    jieguo_aicc = sorted(jieguo,reverse=False, key=lambda x: x[1])  #以aicc排序
    jieguo_bic = sorted(jieguo,reverse=False, key=lambda x: x[2])  #以bic排序
    return jieguo_aicc[0][0],jieguo_bic[0][0]

def sma(x):
    return np.mean(x)        #简单移动平均

def wma(x):
    x = np.array(x).ravel()
    w = np.arange(1,len(x)+1)      #生成等差数列
    return np.sum(x*w)/(len(x)*(len(x)+1)/2)       #加权移动平均（等距）
def ema(x,i):
    x = np.array(x).ravel()
    if i < 1 and i > 0:
        l = len(x)
        w = np.logspace(l, 0, num=l, base=(1-i))      #生成等比数列
    else:
        print('平滑因子范围错误')
    return np.sum(x*w)/np.sum(w)         #指数移动平均
def MA_prediction(data, q, predict_x_n=0):
    ##########################   移动平均预测    ################################
    df = np.array(data).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
    df0 = df.copy()         #准备一个副本，存储真实值以及预测值
    for i in range(len(data)-q+1):
        df[q+i-1] = ema(data[i:i+q],0.5)         #获得简单移动平均获得的预测数列

    df_wu = df0 - df        #获得误差项

    df1 = np.zeros(predict_x_n)      #存储预测值
    for i in range(predict_x_n):
        df1[i] = ema(df0[-q:],0.5)        #得到所有预测值
        df0 = np.append(df0,df1[i])
    ##############################   误差项预测   ###############################
    def MA_AR_prediction(x, p, predict_x_n = 0):           #误差项预测实际就为AR预测，这也是为什么MA模型阶数为0时就转化成AR模型的原因
        df = np.array(x[p:]).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
        df0 = df.copy()         #准备一个副本，为了存储预测的数据
        Y = df[p:].copy()
        h = len(df0)-p
        X = np.zeros((h,p+1))
        for i in range(h):            #得到X矩阵
            X[i][0] = 1
            for v in range(1,p+1):
                X[i,-v] = df[i+v-1]
        sigma = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(Y.T)          #最小二乘法估计参数值
        for i in range(h):
            df0[p+i] = sum(sigma * X[i])        #得到所有预测的估计值
        df00 = df.copy()
        df1 = np.zeros(predict_x_n)
        for i in range(predict_x_n):
            df1[i] = sum(sigma[1:] * df00[-p:][::-1])+sigma[0]       #得到所有预测值
            df00 = np.append(df00,df1[i])
        return df0,df1
    wucha,wucha_predict = MA_AR_prediction(df_wu,q,predict_x_n)
    return wucha,wucha_predict
def sum_s(data,df,q,result_predict):
    data = np.array(data).ravel()
    df = np.array(df).ravel()
    result_predict = np.array(result_predict).ravel()
    if len(data)-len(df)==1+q:
        data0 = np.zeros(len(data))
        data0[0] = data[0]
        for i in range(len(data)-1):
            data0[i+1] = data[i]
        df0 = np.zeros(len(df)+1)
        for i in range(len(df)):
            df0[i+1] = df[i]
        asd = data0[-len(df0):]+df0
        for i in range(len(result_predict)):
            if i == 0:
                result_predict[0]=result_predict[0]+asd[-1]
            else:
                result_predict[i]=result_predict[i]+result_predict[i-1]
                print(result_predict)
        return asd,result_predict
    elif len(data)-len(df)==2+q:
        cha1 = np.diff(data)
        cha1_1,result_predict = sum_s(cha1,df,q,result_predict)
        return sum_s(data,cha1_1,q,result_predict)
    elif len(data)-len(df)==3+q:
        cha1 = np.diff(data)
        cha11 = np.diff(cha1)
        cha1_1,result_predict = sum_s(cha11,df,q,result_predict)
        cha1_1_1,result_predict = sum_s(cha1,cha1_1,q,result_predict)
        return sum_s(data,cha1_1_1,q,result_predict)
def ARIMA(p,q,d,data,predict_n=0):
    df_0 = np.array(data).ravel()
    df = np.diff(df_0,d)
    wucha,wucha_predict = MA_prediction(df, q, predict_n)
    #p_aicc,p_bic = p_finally(10)
    df0,df1 = AR_prediction(df,p,predict_n)
    result = df0[-len(wucha):] - wucha
    result_predict = df1-wucha_predict
    if d != 0:
        result,result_predict = sum_s(df_0,result,q,result_predict)
    return result,result_predict

result,result_predict = ARIMA(4,4,0,data,4)

asd = np.append(result,result_predict)
plt.plot(range(len(data[-60:])),data[-60:],c='b')
plt.plot(range(len(result[-63:])),asd[-63:],c='r')
plt.show()
数学建模
ARIMA预测代码
https://jimes.cn/2024/09/11/ARIMA预测/
作者
Jimes
发布于
2024年9月11日
许可协议
\ No newline at end of file +ARIMA预测代码 - 马锦的博客

ARIMA预测代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
import copy
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import statsmodels.api as sm
from statsmodels.stats.diagnostic import acorr_ljungbox
from statsmodels.graphics.tsaplots import plot_pacf,plot_acf
import warnings
from math import log
from sklearn.metrics import mean_squared_error
warnings.filterwarnings("ignore")
plt.rcParams['axes.unicode_minus'] = False #显示负号
plt.rcParams['font.family'] = ['sans-serif']
plt.rcParams['font.sans-serif'] = ['SimHei']  # 散点图标签可以显示中文

data = pd.read_csv('时间序列预测数据集.csv',parse_dates=['Date'])
data.set_index('Date',inplace=True)     #将时间设置为行索引

####################################   绘制时序图   ############################################
def picture(data):
    plt.figure(figsize=(16,16))
    for i in range(1,5):
        plt.subplot(4,1,i)
        df = data[f"198{1+2*(i-1)}-01-01":f"198{3+2*(i-1)}-01-01"]
        plt.plot(df.index,df['Temp'].values)
        plt.xticks(rotation=45,size=6)
        if i == 1:
            plt.title("时序图")
    plt.show()
    plt.close()
######################################   时间序列检验      #######################################
def inspect(data):
    # 单位根检验-ADF检验
    ADF = sm.tsa.stattools.adfuller(data['Temp'])
    print('ADF值:', format(ADF[0], '.4f'))
    print('拒绝程度值:', ADF[4])      #ADF值需要小于三个拒绝程度值

    # 白噪声检验
    white_noise = acorr_ljungbox(data['Temp'], lags = [6, 12, 24],boxpierce=True) #lag是需要检验的阶数
    print('白噪声检验:\n',white_noise)   #LB和BP统计量的P值都小于显著水平（α = 0.05）,所以拒绝序列为纯随机序列的原假设，认为该序列为非白噪声序列

    fig = plt.figure(figsize=(16,6))

    ax1 = fig.add_subplot(1,2,1)
    plot_acf(data['Temp'],ax=ax1)
    plt.title("自相关图")        #需要拖尾

    ax2 = fig.add_subplot(1,2,2)
    plot_pacf(data['Temp'],ax=ax2)
    plt.title("偏自相关图")      #需要截尾,确定p

    plt.show()
    plt.close()
#####################################    信息准则    ###########################################
def information(df,df0,p):
    n = len(df)
    mse = mean_squared_error(df,df0)
    #aic = n * log(mse) + 2 * p
    aicc = log(mse) + (n+p)/(n-p-2)
    bic = n * log(mse) + p * log(n)
    return aicc,bic
def AR_prediction(x, p, predict_x_n = 0):
    df = np.array(x).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
    df0 = df.copy()         #准备一个副本，为了存储预测的数据
    Y = df[p:].copy()
    h = len(df0)-p
    X = np.zeros((h,p+1))
    for i in range(h):            #得到X矩阵
        X[i][0] = 1
        for v in range(1,p+1):
            X[i,-v] = df[i+v-1]
    sigma = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(Y.T)          #最小二乘法估计参数值
    for i in range(h):
        df0[p+i] = sum(sigma * X[i])      #得到所有预测的估计值
    df00 = df.copy()
    df1 = np.zeros(predict_x_n)
    for i in range(predict_x_n):
        df1[i] = sum(sigma[1:] * df00[-p:][::-1])+sigma[0]        #得到所有预测值
        df00 = np.append(df00,df1[i])
    return df0,df1

#########################################   阶数确定   ##############################################
def p_finally(n):
    jieguo = []
    for i in range(1,n):
        df0,df1 = AR_prediction(data,i)
        aicc,bic = information(data,df0,i)
        jieguo.append([i,aicc,bic])
    jieguo_aicc = sorted(jieguo,reverse=False, key=lambda x: x[1])  #以aicc排序
    jieguo_bic = sorted(jieguo,reverse=False, key=lambda x: x[2])  #以bic排序
    return jieguo_aicc[0][0],jieguo_bic[0][0]

def sma(x):
    return np.mean(x)        #简单移动平均

def wma(x):
    x = np.array(x).ravel()
    w = np.arange(1,len(x)+1)      #生成等差数列
    return np.sum(x*w)/(len(x)*(len(x)+1)/2)       #加权移动平均（等距）
def ema(x,i):
    x = np.array(x).ravel()
    if i < 1 and i > 0:
        l = len(x)
        w = np.logspace(l, 0, num=l, base=(1-i))      #生成等比数列
    else:
        print('平滑因子范围错误')
    return np.sum(x*w)/np.sum(w)         #指数移动平均
def MA_prediction(data, q, predict_x_n=0):
    ##########################   移动平均预测    ################################
    df = np.array(data).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
    df0 = df.copy()         #准备一个副本，存储真实值以及预测值
    for i in range(len(data)-q+1):
        df[q+i-1] = ema(data[i:i+q],0.5)         #获得简单移动平均获得的预测数列

    df_wu = df0 - df        #获得误差项

    df1 = np.zeros(predict_x_n)      #存储预测值
    for i in range(predict_x_n):
        df1[i] = ema(df0[-q:],0.5)        #得到所有预测值
        df0 = np.append(df0,df1[i])
    ##############################   误差项预测   ###############################
    def MA_AR_prediction(x, p, predict_x_n = 0):           #误差项预测实际就为AR预测，这也是为什么MA模型阶数为0时就转化成AR模型的原因
        df = np.array(x[p:]).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
        df0 = df.copy()         #准备一个副本，为了存储预测的数据
        Y = df[p:].copy()
        h = len(df0)-p
        X = np.zeros((h,p+1))
        for i in range(h):            #得到X矩阵
            X[i][0] = 1
            for v in range(1,p+1):
                X[i,-v] = df[i+v-1]
        sigma = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(Y.T)          #最小二乘法估计参数值
        for i in range(h):
            df0[p+i] = sum(sigma * X[i])        #得到所有预测的估计值
        df00 = df.copy()
        df1 = np.zeros(predict_x_n)
        for i in range(predict_x_n):
            df1[i] = sum(sigma[1:] * df00[-p:][::-1])+sigma[0]       #得到所有预测值
            df00 = np.append(df00,df1[i])
        return df0,df1
    wucha,wucha_predict = MA_AR_prediction(df_wu,q,predict_x_n)
    return wucha,wucha_predict
def sum_s(data,df,q,result_predict):
    data = np.array(data).ravel()
    df = np.array(df).ravel()
    result_predict = np.array(result_predict).ravel()
    if len(data)-len(df)==1+q:
        data0 = np.zeros(len(data))
        data0[0] = data[0]
        for i in range(len(data)-1):
            data0[i+1] = data[i]
        df0 = np.zeros(len(df)+1)
        for i in range(len(df)):
            df0[i+1] = df[i]
        asd = data0[-len(df0):]+df0
        for i in range(len(result_predict)):
            if i == 0:
                result_predict[0]=result_predict[0]+asd[-1]
            else:
                result_predict[i]=result_predict[i]+result_predict[i-1]
                print(result_predict)
        return asd,result_predict
    elif len(data)-len(df)==2+q:
        cha1 = np.diff(data)
        cha1_1,result_predict = sum_s(cha1,df,q,result_predict)
        return sum_s(data,cha1_1,q,result_predict)
    elif len(data)-len(df)==3+q:
        cha1 = np.diff(data)
        cha11 = np.diff(cha1)
        cha1_1,result_predict = sum_s(cha11,df,q,result_predict)
        cha1_1_1,result_predict = sum_s(cha1,cha1_1,q,result_predict)
        return sum_s(data,cha1_1_1,q,result_predict)
def ARIMA(p,q,d,data,predict_n=0):
    df_0 = np.array(data).ravel()
    df = np.diff(df_0,d)
    wucha,wucha_predict = MA_prediction(df, q, predict_n)
    #p_aicc,p_bic = p_finally(10)
    df0,df1 = AR_prediction(df,p,predict_n)
    result = df0[-len(wucha):] - wucha
    result_predict = df1-wucha_predict
    if d != 0:
        result,result_predict = sum_s(df_0,result,q,result_predict)
    return result,result_predict

result,result_predict = ARIMA(4,4,0,data,4)

asd = np.append(result,result_predict)
plt.plot(range(len(data[-60:])),data[-60:],c='b')
plt.plot(range(len(result[-63:])),asd[-63:],c='r')
plt.show()
数学建模
ARIMA预测代码
https://jimes.cn/2024/09/11/ARIMA预测/
作者
Jimes
发布于
2024年9月11日
许可协议
+ + \ No newline at end of file diff --git "a/2024/09/11/ARMA\351\242\204\346\265\213/index.html" "b/2024/09/11/ARMA\351\242\204\346\265\213/index.html" index 4319fcd..27d9914 100644 --- "a/2024/09/11/ARMA\351\242\204\346\265\213/index.html" +++ "b/2024/09/11/ARMA\351\242\204\346\265\213/index.html" @@ -1 +1,14 @@ -ARMA预测代码 - 马锦的博客

ARMA预测代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
from math import log
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.metrics import mean_squared_error
np.set_printoptions(threshold=np.inf) # threshold 指定超过多少使用省略号，np.inf代表无限大
np.set_printoptions(suppress=True) #不以科学计数法输出
import warnings
warnings.filterwarnings("ignore")
plt.rcParams['axes.unicode_minus'] = False #显示负号
plt.rcParams['font.family'] = ['sans-serif']
plt.rcParams['font.sans-serif'] = ['SimHei']  # 散点图标签可以显示中文

data = pd.read_csv('时间序列预测数据集.csv',parse_dates=['Date'])
data.set_index('Date',inplace=True)     #将时间设置为行索引

#####################################    信息准则    ###########################################
def information(df,df0,p):
    n = len(df)
    mse = mean_squared_error(df,df0)
    #aic = n * log(mse) + 2 * p
    aicc = log(mse) + (n+p)/(n-p-2)
    bic = n * log(mse) + p * log(n)
    return aicc,bic
def AR_prediction(x, p, predict_x_n = 0):
    df = np.array(x).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
    df0 = df.copy()         #准备一个副本，为了存储预测的数据
    Y = df[p:].copy()
    h = len(df0)-p
    X = np.zeros((h,p+1))
    for i in range(h):            #得到X矩阵
        X[i][0] = 1
        for v in range(1,p+1):
            X[i,-v] = df[i+v-1]
    sigma = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(Y.T)          #最小二乘法估计参数值
    for i in range(h):
        df0[p+i] = sum(sigma * X[i])      #得到所有预测的估计值
    df00 = df.copy()
    df1 = np.zeros(predict_x_n)
    for i in range(predict_x_n):
        df1[i] = sum(np.multiply(sigma , df00[-p:][::-1]))        #得到所有预测值
        df00 = np.append(df00,df1[i])
    return df0,df1

#########################################   阶数确定   ##############################################
def p_finally(n):
    jieguo = []
    for i in range(1,n):
        df0,df1 = AR_prediction(data,i)
        aicc,bic = information(data,df0,i)
        jieguo.append([i,aicc,bic])
    jieguo_aicc = sorted(jieguo,reverse=False, key=lambda x: x[1])  #以aicc排序
    jieguo_bic = sorted(jieguo,reverse=False, key=lambda x: x[2])  #以bic排序
    return jieguo_aicc[0][0],jieguo_bic[0][0]

def sma(x):
    return np.mean(x)        #简单移动平均

def wma(x):
    x = np.array(x).ravel()
    w = np.arange(1,len(x)+1)      #生成等差数列
    return np.sum(x*w)/(len(x)*(len(x)+1)/2)       #加权移动平均（等距）

def ema(x,i):
    x = np.array(x).ravel()
    if i < 1 and i > 0:
        l = len(x)
        w = np.logspace(l, 0, num=l, base=(1-i))      #生成等比数列
    else:
        print('平滑因子范围错误')
    return np.sum(x*w)/np.sum(w)         #指数移动平均

def MA_prediction(data, q, predict_x_n=0):
    ##########################   移动平均预测    ################################
    df = np.array(data).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
    df0 = df.copy()         #准备一个副本，存储真实值以及预测值
    for i in range(len(data)-q+1):
        df[q+i-1] = ema(data[i:i+q],0.5)         #获得简单移动平均获得的预测数列

    df_wu = df0 - df        #获得误差项

    df1 = np.zeros(predict_x_n)      #存储预测值
    for i in range(predict_x_n):
        df1[i] = ema(df0[-q:],0.5)        #得到所有预测值
        df0 = np.append(df0,df1[i])
    ##############################   误差项预测   ###############################
    def MA_AR_prediction(x, p, predict_x_n = 0):           #误差项预测实际就为AR预测，这也是为什么MA模型阶数为0时就转化成AR模型的原因
        df = np.array(x[p:]).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
        df0 = df.copy()         #准备一个副本，为了存储预测的数据
        Y = df[p:].copy()
        h = len(df0)-p
        X = np.zeros((h,p+1))
        for i in range(h):            #得到X矩阵
            X[i][0] = 1
            for v in range(1,p+1):
                X[i,-v] = df[i+v-1]
        sigma = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(Y.T)          #最小二乘法估计参数值
        for i in range(h):
            df0[p+i] = sum(sigma * X[i])        #得到所有预测的估计值
        df00 = df.copy()
        df1 = np.zeros(predict_x_n)
        for i in range(predict_x_n):
            df1[i] = sum(np.multiply(sigma , df00[-p:][::-1]))        #得到所有预测值
            df00 = np.append(df00,df1[i])
        return df0,df1
    wucha,wucha_predict = MA_AR_prediction(df_wu,q,predict_x_n)
    return wucha,wucha_predict

def ARMA(p,q):
    wucha,wucha_predict = MA_prediction(data, q, 0)
    #p_aicc,p_bic = p_finally(10)
    df0,df1 = AR_prediction(data,p,0)
    result = df0[-len(wucha):] - wucha
    return result

result = ARMA(1,6)
plt.figure()
plt.plot(range(60),data[-60:],c = 'black')
plt.plot(range(60),result[-60:],c='red')
plt.show()

print('mse:',mean_squared_error(result,data[-len(result):]))

数学建模
ARMA预测代码
https://jimes.cn/2024/09/11/ARMA预测/
作者
Jimes
发布于
2024年9月11日
许可协议
\ No newline at end of file +ARMA预测代码 - 马锦的博客

ARMA预测代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
from math import log
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.metrics import mean_squared_error
np.set_printoptions(threshold=np.inf) # threshold 指定超过多少使用省略号，np.inf代表无限大
np.set_printoptions(suppress=True) #不以科学计数法输出
import warnings
warnings.filterwarnings("ignore")
plt.rcParams['axes.unicode_minus'] = False #显示负号
plt.rcParams['font.family'] = ['sans-serif']
plt.rcParams['font.sans-serif'] = ['SimHei']  # 散点图标签可以显示中文

data = pd.read_csv('时间序列预测数据集.csv',parse_dates=['Date'])
data.set_index('Date',inplace=True)     #将时间设置为行索引

#####################################    信息准则    ###########################################
def information(df,df0,p):
    n = len(df)
    mse = mean_squared_error(df,df0)
    #aic = n * log(mse) + 2 * p
    aicc = log(mse) + (n+p)/(n-p-2)
    bic = n * log(mse) + p * log(n)
    return aicc,bic
def AR_prediction(x, p, predict_x_n = 0):
    df = np.array(x).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
    df0 = df.copy()         #准备一个副本，为了存储预测的数据
    Y = df[p:].copy()
    h = len(df0)-p
    X = np.zeros((h,p+1))
    for i in range(h):            #得到X矩阵
        X[i][0] = 1
        for v in range(1,p+1):
            X[i,-v] = df[i+v-1]
    sigma = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(Y.T)          #最小二乘法估计参数值
    for i in range(h):
        df0[p+i] = sum(sigma * X[i])      #得到所有预测的估计值
    df00 = df.copy()
    df1 = np.zeros(predict_x_n)
    for i in range(predict_x_n):
        df1[i] = sum(np.multiply(sigma , df00[-p:][::-1]))        #得到所有预测值
        df00 = np.append(df00,df1[i])
    return df0,df1

#########################################   阶数确定   ##############################################
def p_finally(n):
    jieguo = []
    for i in range(1,n):
        df0,df1 = AR_prediction(data,i)
        aicc,bic = information(data,df0,i)
        jieguo.append([i,aicc,bic])
    jieguo_aicc = sorted(jieguo,reverse=False, key=lambda x: x[1])  #以aicc排序
    jieguo_bic = sorted(jieguo,reverse=False, key=lambda x: x[2])  #以bic排序
    return jieguo_aicc[0][0],jieguo_bic[0][0]

def sma(x):
    return np.mean(x)        #简单移动平均

def wma(x):
    x = np.array(x).ravel()
    w = np.arange(1,len(x)+1)      #生成等差数列
    return np.sum(x*w)/(len(x)*(len(x)+1)/2)       #加权移动平均（等距）

def ema(x,i):
    x = np.array(x).ravel()
    if i < 1 and i > 0:
        l = len(x)
        w = np.logspace(l, 0, num=l, base=(1-i))      #生成等比数列
    else:
        print('平滑因子范围错误')
    return np.sum(x*w)/np.sum(w)         #指数移动平均

def MA_prediction(data, q, predict_x_n=0):
    ##########################   移动平均预测    ################################
    df = np.array(data).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
    df0 = df.copy()         #准备一个副本，存储真实值以及预测值
    for i in range(len(data)-q+1):
        df[q+i-1] = ema(data[i:i+q],0.5)         #获得简单移动平均获得的预测数列

    df_wu = df0 - df        #获得误差项

    df1 = np.zeros(predict_x_n)      #存储预测值
    for i in range(predict_x_n):
        df1[i] = ema(df0[-q:],0.5)        #得到所有预测值
        df0 = np.append(df0,df1[i])
    ##############################   误差项预测   ###############################
    def MA_AR_prediction(x, p, predict_x_n = 0):           #误差项预测实际就为AR预测，这也是为什么MA模型阶数为0时就转化成AR模型的原因
        df = np.array(x[p:]).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
        df0 = df.copy()         #准备一个副本，为了存储预测的数据
        Y = df[p:].copy()
        h = len(df0)-p
        X = np.zeros((h,p+1))
        for i in range(h):            #得到X矩阵
            X[i][0] = 1
            for v in range(1,p+1):
                X[i,-v] = df[i+v-1]
        sigma = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(Y.T)          #最小二乘法估计参数值
        for i in range(h):
            df0[p+i] = sum(sigma * X[i])        #得到所有预测的估计值
        df00 = df.copy()
        df1 = np.zeros(predict_x_n)
        for i in range(predict_x_n):
            df1[i] = sum(np.multiply(sigma , df00[-p:][::-1]))        #得到所有预测值
            df00 = np.append(df00,df1[i])
        return df0,df1
    wucha,wucha_predict = MA_AR_prediction(df_wu,q,predict_x_n)
    return wucha,wucha_predict

def ARMA(p,q):
    wucha,wucha_predict = MA_prediction(data, q, 0)
    #p_aicc,p_bic = p_finally(10)
    df0,df1 = AR_prediction(data,p,0)
    result = df0[-len(wucha):] - wucha
    return result

result = ARMA(1,6)
plt.figure()
plt.plot(range(60),data[-60:],c = 'black')
plt.plot(range(60),result[-60:],c='red')
plt.show()

print('mse:',mean_squared_error(result,data[-len(result):]))

数学建模
ARMA预测代码
https://jimes.cn/2024/09/11/ARMA预测/
作者
Jimes
发布于
2024年9月11日
许可协议
+ + \ No newline at end of file diff --git "a/2024/09/11/AR\351\242\204\346\265\213/index.html" "b/2024/09/11/AR\351\242\204\346\265\213/index.html" index 5d71647..0fd8017 100644 --- "a/2024/09/11/AR\351\242\204\346\265\213/index.html" +++ "b/2024/09/11/AR\351\242\204\346\265\213/index.html" @@ -1 +1,14 @@ -AR预测代码 - 马锦的博客

AR预测代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
from math import log
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.metrics import mean_squared_error
from statsmodels.stats.diagnostic import acorr_ljungbox
from statsmodels.graphics.tsaplots import plot_pacf,plot_acf
import statsmodels.api as sm
import warnings
warnings.filterwarnings("ignore")
np.set_printoptions(threshold=np.inf) # threshold 指定超过多少使用省略号，np.inf代表无限大
np.set_printoptions(suppress=True) #不以科学计数法输出
plt.rcParams['axes.unicode_minus'] = False #显示负号
plt.rcParams['font.family'] = ['sans-serif']
plt.rcParams['font.sans-serif'] = ['SimHei']  # 散点图标签可以显示中文

data = pd.read_csv('时间序列预测数据集.csv',parse_dates=['Date'])
data.set_index('Date',inplace=True)     #将时间设置为行索引
#data = data["1981-01-01":"1982-01-01"]
####################################   绘制时序图   ############################################
def picture(data):
    plt.figure(figsize=(16,16))
    for i in range(1,5):
        plt.subplot(4,1,i)
        df = data[f"198{1+2*(i-1)}-01-01":f"198{3+2*(i-1)}-01-01"]
        plt.plot(df.index,df['Temp'])
        plt.xticks(rotation=45,size=6)
        if i == 1:
            plt.title("时序图")
    plt.show()
    plt.close()
######################################   时间序列检验      #######################################
def inspect(data):
    # 单位根检验-ADF检验
    ADF = sm.tsa.stattools.adfuller(data['Temp'])
    print('ADF值:', format(ADF[0], '.4f'))
    print('拒绝程度值:', ADF[4])      #ADF值需要小于三个拒绝程度值

    # 白噪声检验
    white_noise = acorr_ljungbox(data['Temp'], lags = [6, 12, 24],boxpierce=True) #lag是需要检验的阶数
    print('白噪声检验:\n',white_noise)   #LB和BP统计量的P值都小于显著水平（α = 0.05）,所以拒绝序列为纯随机序列的原假设，认为该序列为非白噪声序列

    fig = plt.figure(figsize=(16,6))

    ax1 = fig.add_subplot(1,2,1)
    plot_acf(data['Temp'],ax=ax1)
    plt.title("自相关图")        #需要拖尾,确定q

    ax2 = fig.add_subplot(1,2,2)
    plot_pacf(data['Temp'],ax=ax2)
    plt.title("偏自相关图")      #需要截尾,确定p

    plt.show()
    plt.close()
#####################################    信息准则    ###########################################
def information(df,df0,p):
    n = len(df)
    mse = mean_squared_error(df,df0)
    #aic = n * log(mse) + 2 * p
    aicc = log(mse) + (n+p)/(n-p-2)
    bic = n * log(mse) + p * log(n)
    return aicc,bic

####################################     模型预测     ##########################################
def AR_prediction(x, p, predict_x_n = 0):
    df = np.array(x).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
    df0 = df.copy()         #准备一个副本，为了存储预测的数据
    Y = df[p:].copy()
    h = len(df0)-p
    X = np.zeros((h,p+1))
    for i in range(h):            #得到X矩阵
        X[i][0] = 1
        for v in range(1,p+1):
            X[i][-v] = df[i+v-1]
    sigma = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(Y.T)          #最小二乘法估计参数值
    print(sigma)
    for i in range(h):
        df0[p+i] = sum(sigma * X[i])        #得到所有预测的估计值
    df00 = df.copy()
    df1 = np.zeros(predict_x_n)
    for i in range(predict_x_n):
        df1[i] = sum(np.multiply(sigma , df00[-p:][::-1]))        #得到所有预测值
        df00 = np.append(df00,df1[i])
    return df0,df1

#########################################   阶数确定   ##############################################
def p_finally(n):
    jieguo = []
    for i in range(1,n):
        df0,df1 = AR_prediction(data,i)
        aicc,bic = information(data,df0,i)
        jieguo.append([i,aicc,bic])
    jieguo_aicc = sorted(jieguo,reverse=False, key=lambda x: x[1])  #以aicc排序
    jieguo_bic = sorted(jieguo,reverse=False, key=lambda x: x[2])  #以bic排序

    return jieguo_aicc[0][0],jieguo_bic[0][0]

#################################   得到最终结果   ###################################
#images(data)
#inspect(data)

#p_aicc,p_bic = p_finally(30)
#print(p_aicc)
df0,df1 = AR_prediction(data,4,0)

plt.figure()
plt.plot(range(50),data[-50:],c = 'black')
plt.plot(range(50),df0[-50:],c='red')
plt.show()

数学建模
AR预测代码
https://jimes.cn/2024/09/11/AR预测/
作者
Jimes
发布于
2024年9月11日
许可协议
\ No newline at end of file +AR预测代码 - 马锦的博客

AR预测代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
from math import log
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.metrics import mean_squared_error
from statsmodels.stats.diagnostic import acorr_ljungbox
from statsmodels.graphics.tsaplots import plot_pacf,plot_acf
import statsmodels.api as sm
import warnings
warnings.filterwarnings("ignore")
np.set_printoptions(threshold=np.inf) # threshold 指定超过多少使用省略号，np.inf代表无限大
np.set_printoptions(suppress=True) #不以科学计数法输出
plt.rcParams['axes.unicode_minus'] = False #显示负号
plt.rcParams['font.family'] = ['sans-serif']
plt.rcParams['font.sans-serif'] = ['SimHei']  # 散点图标签可以显示中文

data = pd.read_csv('时间序列预测数据集.csv',parse_dates=['Date'])
data.set_index('Date',inplace=True)     #将时间设置为行索引
#data = data["1981-01-01":"1982-01-01"]
####################################   绘制时序图   ############################################
def picture(data):
    plt.figure(figsize=(16,16))
    for i in range(1,5):
        plt.subplot(4,1,i)
        df = data[f"198{1+2*(i-1)}-01-01":f"198{3+2*(i-1)}-01-01"]
        plt.plot(df.index,df['Temp'])
        plt.xticks(rotation=45,size=6)
        if i == 1:
            plt.title("时序图")
    plt.show()
    plt.close()
######################################   时间序列检验      #######################################
def inspect(data):
    # 单位根检验-ADF检验
    ADF = sm.tsa.stattools.adfuller(data['Temp'])
    print('ADF值:', format(ADF[0], '.4f'))
    print('拒绝程度值:', ADF[4])      #ADF值需要小于三个拒绝程度值

    # 白噪声检验
    white_noise = acorr_ljungbox(data['Temp'], lags = [6, 12, 24],boxpierce=True) #lag是需要检验的阶数
    print('白噪声检验:\n',white_noise)   #LB和BP统计量的P值都小于显著水平（α = 0.05）,所以拒绝序列为纯随机序列的原假设，认为该序列为非白噪声序列

    fig = plt.figure(figsize=(16,6))

    ax1 = fig.add_subplot(1,2,1)
    plot_acf(data['Temp'],ax=ax1)
    plt.title("自相关图")        #需要拖尾,确定q

    ax2 = fig.add_subplot(1,2,2)
    plot_pacf(data['Temp'],ax=ax2)
    plt.title("偏自相关图")      #需要截尾,确定p

    plt.show()
    plt.close()
#####################################    信息准则    ###########################################
def information(df,df0,p):
    n = len(df)
    mse = mean_squared_error(df,df0)
    #aic = n * log(mse) + 2 * p
    aicc = log(mse) + (n+p)/(n-p-2)
    bic = n * log(mse) + p * log(n)
    return aicc,bic

####################################     模型预测     ##########################################
def AR_prediction(x, p, predict_x_n = 0):
    df = np.array(x).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
    df0 = df.copy()         #准备一个副本，为了存储预测的数据
    Y = df[p:].copy()
    h = len(df0)-p
    X = np.zeros((h,p+1))
    for i in range(h):            #得到X矩阵
        X[i][0] = 1
        for v in range(1,p+1):
            X[i][-v] = df[i+v-1]
    sigma = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(Y.T)          #最小二乘法估计参数值
    print(sigma)
    for i in range(h):
        df0[p+i] = sum(sigma * X[i])        #得到所有预测的估计值
    df00 = df.copy()
    df1 = np.zeros(predict_x_n)
    for i in range(predict_x_n):
        df1[i] = sum(np.multiply(sigma , df00[-p:][::-1]))        #得到所有预测值
        df00 = np.append(df00,df1[i])
    return df0,df1

#########################################   阶数确定   ##############################################
def p_finally(n):
    jieguo = []
    for i in range(1,n):
        df0,df1 = AR_prediction(data,i)
        aicc,bic = information(data,df0,i)
        jieguo.append([i,aicc,bic])
    jieguo_aicc = sorted(jieguo,reverse=False, key=lambda x: x[1])  #以aicc排序
    jieguo_bic = sorted(jieguo,reverse=False, key=lambda x: x[2])  #以bic排序

    return jieguo_aicc[0][0],jieguo_bic[0][0]

#################################   得到最终结果   ###################################
#images(data)
#inspect(data)

#p_aicc,p_bic = p_finally(30)
#print(p_aicc)
df0,df1 = AR_prediction(data,4,0)

plt.figure()
plt.plot(range(50),data[-50:],c = 'black')
plt.plot(range(50),df0[-50:],c='red')
plt.show()

数学建模
AR预测代码
https://jimes.cn/2024/09/11/AR预测/
作者
Jimes
发布于
2024年9月11日
许可协议
+ + \ No newline at end of file diff --git "a/2024/09/11/MA\351\242\204\346\265\213/index.html" "b/2024/09/11/MA\351\242\204\346\265\213/index.html" index 19c8db2..aceb087 100644 --- "a/2024/09/11/MA\351\242\204\346\265\213/index.html" +++ "b/2024/09/11/MA\351\242\204\346\265\213/index.html" @@ -1 +1,14 @@ -MA预测代码 - 马锦的博客

MA预测代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
np.set_printoptions(threshold=np.inf) # threshold 指定超过多少使用省略号，np.inf代表无限大
np.set_printoptions(suppress=True) #不以科学计数法输出
import warnings
warnings.filterwarnings("ignore")
plt.rcParams['axes.unicode_minus'] = False #显示负号
plt.rcParams['font.family'] = ['sans-serif']
plt.rcParams['font.sans-serif'] = ['SimHei']  # 散点图标签可以显示中文

data = pd.read_csv('时间序列预测数据集.csv',parse_dates=['Date'])
data.set_index('Date',inplace=True)     #将时间设置为行索引

def sma(x):
    return np.mean(x)        #简单移动平均

def wma(x):
    x = np.array(x).ravel()
    w = np.arange(1,len(x)+1)      #生成等差数列
    return np.sum(x*w)/(len(x)*(len(x)+1)/2)       #加权移动平均（等距）

def ema(x,i):
    x = np.array(x).ravel()
    if i < 1 and i > 0:
        l = len(x)
        w = np.logspace(l, 0, num=l, base=(1-i))      #生成等比数列
    else:
        print('平滑因子范围错误')
    return np.sum(x*w)/np.sum(w)         #指数移动平均

def ma_prediction(data, q, predict_x_n=0):
##########################   移动平均预测    ################################
    df = np.array(data).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
    df0 = df.copy()         #准备一个副本，存储真实值以及预测值
    for i in range(len(data)-q+1):
        df[q+i-1] = ema(data[i:i+q],0.5)         #获得简单移动平均获得的预测数列

    df_wu = df0 - df        #获得误差项

    df1 = np.zeros(predict_x_n)      #存储预测值
    for i in range(predict_x_n):
        df1[i] = ema(df0[-q:],0.5)        #得到所有预测值
        df0 = np.append(df0,df1[i])
##############################   误差项预测   ###############################
    def AR_prediction(x, p, predict_x_n = 0):           #误差项预测实际就为AR预测，这也是为什么MA模型阶数为0时就转化成AR模型的原因
        df = np.array(x[p:]).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
        df0 = df.copy()         #准备一个副本，为了存储预测的数据
        Y = df[p:].copy()
        h = len(df0)-p
        X = np.zeros((h,p+1))
        for i in range(h):            #得到X矩阵
            X[i][0] = 1
            for v in range(1,p+1):
                X[i,-v] = df[i+v-1]
        sigma = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(Y.T)          #最小二乘法估计参数值
        for i in range(h):
            df0[p+i] = sum(np.multiply(sigma , X[i]))        #得到所有预测的估计值
        df00 = df.copy()
        df1 = np.zeros(predict_x_n)
        for i in range(predict_x_n):
            df1[i] = sum(np.multiply(sigma , df00[-p:][::-1]))        #得到所有预测值
            df00 = np.append(df00,df1[i])
        return df0,df1
    wucha,wucha_predict = AR_prediction(df_wu,q,predict_x_n)
    result = df[-len(wucha):] - wucha
    predict = df1 - wucha_predict
    return result,predict

result,predict = ma_prediction(data, 6, 0)

plt.figure()
plt.plot(range(60),data[-60:],c = 'black')
plt.plot(range(60),result[-60:],c='red')
plt.show()
数学建模
MA预测代码
https://jimes.cn/2024/09/11/MA预测/
作者
Jimes
发布于
2024年9月11日
许可协议
\ No newline at end of file +MA预测代码 - 马锦的博客

MA预测代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
np.set_printoptions(threshold=np.inf) # threshold 指定超过多少使用省略号，np.inf代表无限大
np.set_printoptions(suppress=True) #不以科学计数法输出
import warnings
warnings.filterwarnings("ignore")
plt.rcParams['axes.unicode_minus'] = False #显示负号
plt.rcParams['font.family'] = ['sans-serif']
plt.rcParams['font.sans-serif'] = ['SimHei']  # 散点图标签可以显示中文

data = pd.read_csv('时间序列预测数据集.csv',parse_dates=['Date'])
data.set_index('Date',inplace=True)     #将时间设置为行索引

def sma(x):
    return np.mean(x)        #简单移动平均

def wma(x):
    x = np.array(x).ravel()
    w = np.arange(1,len(x)+1)      #生成等差数列
    return np.sum(x*w)/(len(x)*(len(x)+1)/2)       #加权移动平均（等距）

def ema(x,i):
    x = np.array(x).ravel()
    if i < 1 and i > 0:
        l = len(x)
        w = np.logspace(l, 0, num=l, base=(1-i))      #生成等比数列
    else:
        print('平滑因子范围错误')
    return np.sum(x*w)/np.sum(w)         #指数移动平均

def ma_prediction(data, q, predict_x_n=0):
##########################   移动平均预测    ################################
    df = np.array(data).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
    df0 = df.copy()         #准备一个副本，存储真实值以及预测值
    for i in range(len(data)-q+1):
        df[q+i-1] = ema(data[i:i+q],0.5)         #获得简单移动平均获得的预测数列

    df_wu = df0 - df        #获得误差项

    df1 = np.zeros(predict_x_n)      #存储预测值
    for i in range(predict_x_n):
        df1[i] = ema(df0[-q:],0.5)        #得到所有预测值
        df0 = np.append(df0,df1[i])
##############################   误差项预测   ###############################
    def AR_prediction(x, p, predict_x_n = 0):           #误差项预测实际就为AR预测，这也是为什么MA模型阶数为0时就转化成AR模型的原因
        df = np.array(x[p:]).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
        df0 = df.copy()         #准备一个副本，为了存储预测的数据
        Y = df[p:].copy()
        h = len(df0)-p
        X = np.zeros((h,p+1))
        for i in range(h):            #得到X矩阵
            X[i][0] = 1
            for v in range(1,p+1):
                X[i,-v] = df[i+v-1]
        sigma = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(Y.T)          #最小二乘法估计参数值
        for i in range(h):
            df0[p+i] = sum(np.multiply(sigma , X[i]))        #得到所有预测的估计值
        df00 = df.copy()
        df1 = np.zeros(predict_x_n)
        for i in range(predict_x_n):
            df1[i] = sum(np.multiply(sigma , df00[-p:][::-1]))        #得到所有预测值
            df00 = np.append(df00,df1[i])
        return df0,df1
    wucha,wucha_predict = AR_prediction(df_wu,q,predict_x_n)
    result = df[-len(wucha):] - wucha
    predict = df1 - wucha_predict
    return result,predict

result,predict = ma_prediction(data, 6, 0)

plt.figure()
plt.plot(range(60),data[-60:],c = 'black')
plt.plot(range(60),result[-60:],c='red')
plt.show()
数学建模
MA预测代码
https://jimes.cn/2024/09/11/MA预测/
作者
Jimes
发布于
2024年9月11日
许可协议
+ + \ No newline at end of file diff --git "a/2024/09/11/SARIMA\351\242\204\346\265\213/index.html" "b/2024/09/11/SARIMA\351\242\204\346\265\213/index.html" index 2aa9a00..a437d67 100644 --- "a/2024/09/11/SARIMA\351\242\204\346\265\213/index.html" +++ "b/2024/09/11/SARIMA\351\242\204\346\265\213/index.html" @@ -1 +1,14 @@ -SARIMA预测代码 - 马锦的博客

SARIMA预测代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
import copy
from math import log
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.metrics import mean_squared_error
np.set_printoptions(threshold=np.inf) # threshold 指定超过多少使用省略号，np.inf代表无限大
np.set_printoptions(suppress=True) #不以科学计数法输出
import warnings
warnings.filterwarnings("ignore")
plt.rcParams['axes.unicode_minus'] = False #显示负号
plt.rcParams['font.family'] = ['sans-serif']
plt.rcParams['font.sans-serif'] = ['SimHei']  # 散点图标签可以显示中文


#####################################    信息准则    ###########################################
def information(df,df0,p):
    n = len(df)
    mse = mean_squared_error(df,df0)
    #aic = n * log(mse) + 2 * p
    aicc = log(mse) + (n+p)/(n-p-2)
    bic = n * log(mse) + p * log(n)
    return aicc,bic

def AR_prediction(x, p, predict_x_n = 0):
    df = np.array(x).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
    df0 = df.copy()         #准备一个副本，为了存储预测的数据
    Y = df[p:].copy()
    h = len(df0)-p
    X = np.zeros((h,p))
    for i in range(h):            #得到X矩阵
        for v in range(1,p+1):
            X[i,-v] = df[i+v-1]
    sigma = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(Y.T)          #最小二乘法估计参数值
    for i in range(h):
        df0[p+i] = sum(np.multiply(sigma , X[i]))        #得到所有预测的估计值
    df00 = df.copy()
    df1 = np.zeros(predict_x_n)
    for i in range(predict_x_n):
        df1[i] = sum(np.multiply(sigma , df00[-p:][::-1]))        #得到所有预测值
        df00 = np.append(df00,df1[i])
    return df0,df1,sigma
def SAR(x,p,s,predict_x_n=0):
    x = np.array(x).ravel()
    df0 = x.copy()
    Y = x[s*p:].copy()
    h = len(x) - p*s
    X = np.zeros((h,p))
    for t in range(h):
        for i in range(1,p+1):
            X[t][-i] = x[p*s+t-i*s]
    sigma = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(Y.T)          #最小二乘法估计参数值
    for i in range(h):
        df0[p*s+i] = sum(sigma * X[i])        #得到所有预测的估计值
    df00 = x.copy()
    df1 = np.zeros(predict_x_n)
    for i in range(predict_x_n):
        df1[i] = sum(np.multiply(sigma , df00[-p:][::-1]))        #得到所有预测值
        df00 = np.append(df00,df1[i])
    return df0,df1,sigma

#########################################   阶数确定   ##############################################
def p_finally(n):
    jieguo = []
    for i in range(1,n):
        df0,df1 = AR_prediction(data,i)
        aicc,bic = information(data,df0,i)
        jieguo.append([i,aicc,bic])
    jieguo_aicc = sorted(jieguo,reverse=False, key=lambda x: x[1])  #以aicc排序
    jieguo_bic = sorted(jieguo,reverse=False, key=lambda x: x[2])  #以bic排序
    return jieguo_aicc[0][0],jieguo_bic[0][0]

def MA_prediction(data, q, predict_x_n=0):
    def sma(x):
        return np.mean(x)        #简单移动平均
    def wma(x):
        x = np.array(x).ravel()
        w = np.arange(1,len(x)+1)      #生成等差数列
        return np.sum(x*w)/(len(x)*(len(x)+1)/2)       #加权移动平均（等距）
    def ema(x,i):
        x = np.array(x).ravel()
        if i < 1 and i > 0:
            l = len(x)
            w = np.logspace(l, 0, num=l, base=(1-i))      #生成等比数列
        else:
            print('平滑因子范围错误')
        return np.sum(x*w)/np.sum(w)         #指数移动平均
    ##########################   移动平均预测    ################################
    df = np.array(data).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
    df0 = df.copy()         #准备一个副本，存储真实值以及预测值
    for i in range(len(df0)-q+1):
        df[q+i-1] = ema(df0[i:i+q],0.5)         #获得简单移动平均获得的预测数列

    df_wu = df0 - df        #获得误差项

    df1 = np.zeros(predict_x_n)      #存储预测值
    for i in range(predict_x_n):
        df1[i] = ema(df0[-q:],0.5)        #得到所有预测值
        df0 = np.append(df0,df1[i])
    ##############################   误差项预测   ###############################
    def MA_AR_prediction(x, p, predict_x_n = 0):           #误差项预测实际就为AR预测，这也是为什么MA模型阶数为0时就转化成AR模型的原因
        df = np.array(x[p:]).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
        df0 = df.copy()         #准备一个副本，为了存储预测的数据
        Y = df[p:].copy()
        h = len(df0)-p
        X = np.zeros((h,p))
        for i in range(h):            #得到X矩阵
            for v in range(1,p+1):
                X[i,-v] = df[i+v-1]
        sigma = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(Y.T)          #最小二乘法估计参数值
        for i in range(h):
            df0[p+i] = sum(np.multiply(sigma , X[i]))        #得到所有预测的估计值
        df00 = df.copy()
        df1 = np.zeros(predict_x_n)
        for i in range(predict_x_n):
            df1[i] = sum(np.multiply(sigma , df00[-p:][::-1]))        #得到所有预测值
            df00 = np.append(df00,df1[i])
        return df0,df1,sigma
    wucha,wucha_predict,sigma = MA_AR_prediction(df_wu,q,predict_x_n)
    return wucha,wucha_predict,sigma,df_wu

def SMA(data,q,s,predict_x_n=0):
    def sma(x):
        return np.mean(x)        #简单移动平均
    def wma(x):
        x = np.array(x).ravel()
        w = np.arange(1,len(x)+1)      #生成等差数列
        return np.sum(x*w)/(len(x)*(len(x)+1)/2)       #加权移动平均（等距）
    def ema(x,i):
        x = np.array(x).ravel()
        if i < 1 and i > 0:
            l = len(x)
            w = np.logspace(l, 0, num=l, base=(1-i))      #生成等比数列
        else:
            print('平滑因子范围错误')
        return np.sum(x*w)/np.sum(w)         #指数移动平均
    ##########################   移动平均预测    ################################
    df = np.array(data).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
    df0 = df.copy()         #准备一个副本，存储真实值以及预测值
    h = len(data) - q*s
    X = np.zeros((h,q))
    for t in range(h):
        for i in range(1,q+1):
            X[t][-i] = df[q*s+t-i*s]
    for i in range(h):
        df[q*s+i] = ema(X[i],0.5)         #获得简单移动平均获得的预测数列

    df_wu = df0 - df        #获得误差项

    df1 = np.zeros(predict_x_n)      #存储预测值
    for i in range(predict_x_n):
        df1[i] = ema(df0[-q:],0.5)        #得到所有预测值
        df0 = np.append(df0,df1[i])
    ##############################   误差项预测   ###############################
    def SAR(x,p,s,predict_x_n=0):
        x = np.array(x[p*s:]).ravel()
        df0 = x.copy()
        Y = x[s*p:].copy()
        h = len(x) - p*s
        X = np.zeros((h,p))
        for t in range(h):
            for i in range(1,p+1):
                X[t][-i] = x[p*s+t-i*s]
        sigma = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(Y.T)          #最小二乘法估计参数值
        for i in range(h):
            df0[p*s+i] = sum(np.multiply(sigma , X[i]))        #得到所有预测的估计值
        df00 = x.copy()
        df1 = np.zeros(predict_x_n)
        for i in range(predict_x_n):
            df1[i] = sum(np.multiply(sigma , df00[-p:][::-1]))        #得到所有预测值
            df00 = np.append(df00,df1[i])
        return df0,df1,sigma
    wucha,wucha_predict,sigma = SAR(df_wu,q,s,predict_x_n)
    return wucha,wucha_predict,sigma
def SARIMA(p,q,P,Q,data,m):
    #p_aicc,p_bic = p_finally(10)
    df0,df1,sigma = AR_prediction(data,p,0)
    wucha,wucha_predict,sigma1,df_wu = MA_prediction(data, q, 0)
    a,b,sigma2 = SAR(data,P,m,0)
    c,d,sigma3 = SMA(data,Q,m,0)
    sigma = sigma[::-1]
    sigma1 = sigma1[::-1]
    sigma2 = sigma2[::-1]
    sigma3 = sigma3[::-1]
    sigma22 = np.append(np.array([1]),sigma2)
    sigma33 = np.append(np.array([1]),sigma3)
    result = []
    for t in range(30,len(data)+1):
        sar = 0
        for p in range(p):
            for P in range(P+1):
                sar += sigma[p] * data[t-p-1-P*m] * sigma22[P]
        sar += sum(sigma2 * np.array([data[t-i*m] for i in range(1,P+1)]))
        sma = 0
        for q in range(q):
            for Q in range(Q+1):
                sma += sigma1[q] * df_wu[t-q-1-Q*m] * sigma33[Q]
        sma += sum(sigma3 * np.array([df_wu[t-i*m] for i in range(1,Q+1)]))
        result.append(sar + sma)
    return result


data0 = pd.read_csv('时间序列预测数据集.csv',parse_dates=['Date'])
data0.set_index('Date',inplace=True)     #将时间设置为行索引
data=np.array(copy.deepcopy(data0)).ravel()
#data = data.reshape((10,365))    #季节性差分
#data=np.diff(data,1)
#data = data.ravel()
result = SARIMA(6,7,2,2,data,365)
plt.figure(figsize=(15, 7.5))
plt.plot(range(500),data[-500:],c = 'black',label='actual')
plt.plot(range(500),result[-500:],c='red',label='model')
plt.show()

print('mse:',mean_squared_error(result,data[-len(result):]))

数学建模
SARIMA预测代码
https://jimes.cn/2024/09/11/SARIMA预测/
作者
Jimes
发布于
2024年9月11日
许可协议
\ No newline at end of file +SARIMA预测代码 - 马锦的博客

SARIMA预测代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
import copy
from math import log
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.metrics import mean_squared_error
np.set_printoptions(threshold=np.inf) # threshold 指定超过多少使用省略号，np.inf代表无限大
np.set_printoptions(suppress=True) #不以科学计数法输出
import warnings
warnings.filterwarnings("ignore")
plt.rcParams['axes.unicode_minus'] = False #显示负号
plt.rcParams['font.family'] = ['sans-serif']
plt.rcParams['font.sans-serif'] = ['SimHei']  # 散点图标签可以显示中文


#####################################    信息准则    ###########################################
def information(df,df0,p):
    n = len(df)
    mse = mean_squared_error(df,df0)
    #aic = n * log(mse) + 2 * p
    aicc = log(mse) + (n+p)/(n-p-2)
    bic = n * log(mse) + p * log(n)
    return aicc,bic

def AR_prediction(x, p, predict_x_n = 0):
    df = np.array(x).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
    df0 = df.copy()         #准备一个副本，为了存储预测的数据
    Y = df[p:].copy()
    h = len(df0)-p
    X = np.zeros((h,p))
    for i in range(h):            #得到X矩阵
        for v in range(1,p+1):
            X[i,-v] = df[i+v-1]
    sigma = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(Y.T)          #最小二乘法估计参数值
    for i in range(h):
        df0[p+i] = sum(np.multiply(sigma , X[i]))        #得到所有预测的估计值
    df00 = df.copy()
    df1 = np.zeros(predict_x_n)
    for i in range(predict_x_n):
        df1[i] = sum(np.multiply(sigma , df00[-p:][::-1]))        #得到所有预测值
        df00 = np.append(df00,df1[i])
    return df0,df1,sigma
def SAR(x,p,s,predict_x_n=0):
    x = np.array(x).ravel()
    df0 = x.copy()
    Y = x[s*p:].copy()
    h = len(x) - p*s
    X = np.zeros((h,p))
    for t in range(h):
        for i in range(1,p+1):
            X[t][-i] = x[p*s+t-i*s]
    sigma = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(Y.T)          #最小二乘法估计参数值
    for i in range(h):
        df0[p*s+i] = sum(sigma * X[i])        #得到所有预测的估计值
    df00 = x.copy()
    df1 = np.zeros(predict_x_n)
    for i in range(predict_x_n):
        df1[i] = sum(np.multiply(sigma , df00[-p:][::-1]))        #得到所有预测值
        df00 = np.append(df00,df1[i])
    return df0,df1,sigma

#########################################   阶数确定   ##############################################
def p_finally(n):
    jieguo = []
    for i in range(1,n):
        df0,df1 = AR_prediction(data,i)
        aicc,bic = information(data,df0,i)
        jieguo.append([i,aicc,bic])
    jieguo_aicc = sorted(jieguo,reverse=False, key=lambda x: x[1])  #以aicc排序
    jieguo_bic = sorted(jieguo,reverse=False, key=lambda x: x[2])  #以bic排序
    return jieguo_aicc[0][0],jieguo_bic[0][0]

def MA_prediction(data, q, predict_x_n=0):
    def sma(x):
        return np.mean(x)        #简单移动平均
    def wma(x):
        x = np.array(x).ravel()
        w = np.arange(1,len(x)+1)      #生成等差数列
        return np.sum(x*w)/(len(x)*(len(x)+1)/2)       #加权移动平均（等距）
    def ema(x,i):
        x = np.array(x).ravel()
        if i < 1 and i > 0:
            l = len(x)
            w = np.logspace(l, 0, num=l, base=(1-i))      #生成等比数列
        else:
            print('平滑因子范围错误')
        return np.sum(x*w)/np.sum(w)         #指数移动平均
    ##########################   移动平均预测    ################################
    df = np.array(data).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
    df0 = df.copy()         #准备一个副本，存储真实值以及预测值
    for i in range(len(df0)-q+1):
        df[q+i-1] = ema(df0[i:i+q],0.5)         #获得简单移动平均获得的预测数列

    df_wu = df0 - df        #获得误差项

    df1 = np.zeros(predict_x_n)      #存储预测值
    for i in range(predict_x_n):
        df1[i] = ema(df0[-q:],0.5)        #得到所有预测值
        df0 = np.append(df0,df1[i])
    ##############################   误差项预测   ###############################
    def MA_AR_prediction(x, p, predict_x_n = 0):           #误差项预测实际就为AR预测，这也是为什么MA模型阶数为0时就转化成AR模型的原因
        df = np.array(x[p:]).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
        df0 = df.copy()         #准备一个副本，为了存储预测的数据
        Y = df[p:].copy()
        h = len(df0)-p
        X = np.zeros((h,p))
        for i in range(h):            #得到X矩阵
            for v in range(1,p+1):
                X[i,-v] = df[i+v-1]
        sigma = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(Y.T)          #最小二乘法估计参数值
        for i in range(h):
            df0[p+i] = sum(np.multiply(sigma , X[i]))        #得到所有预测的估计值
        df00 = df.copy()
        df1 = np.zeros(predict_x_n)
        for i in range(predict_x_n):
            df1[i] = sum(np.multiply(sigma , df00[-p:][::-1]))        #得到所有预测值
            df00 = np.append(df00,df1[i])
        return df0,df1,sigma
    wucha,wucha_predict,sigma = MA_AR_prediction(df_wu,q,predict_x_n)
    return wucha,wucha_predict,sigma,df_wu

def SMA(data,q,s,predict_x_n=0):
    def sma(x):
        return np.mean(x)        #简单移动平均
    def wma(x):
        x = np.array(x).ravel()
        w = np.arange(1,len(x)+1)      #生成等差数列
        return np.sum(x*w)/(len(x)*(len(x)+1)/2)       #加权移动平均（等距）
    def ema(x,i):
        x = np.array(x).ravel()
        if i < 1 and i > 0:
            l = len(x)
            w = np.logspace(l, 0, num=l, base=(1-i))      #生成等比数列
        else:
            print('平滑因子范围错误')
        return np.sum(x*w)/np.sum(w)         #指数移动平均
    ##########################   移动平均预测    ################################
    df = np.array(data).ravel()     #将数据转化为numpy格式，并将其转化为一维列表
    df0 = df.copy()         #准备一个副本，存储真实值以及预测值
    h = len(data) - q*s
    X = np.zeros((h,q))
    for t in range(h):
        for i in range(1,q+1):
            X[t][-i] = df[q*s+t-i*s]
    for i in range(h):
        df[q*s+i] = ema(X[i],0.5)         #获得简单移动平均获得的预测数列

    df_wu = df0 - df        #获得误差项

    df1 = np.zeros(predict_x_n)      #存储预测值
    for i in range(predict_x_n):
        df1[i] = ema(df0[-q:],0.5)        #得到所有预测值
        df0 = np.append(df0,df1[i])
    ##############################   误差项预测   ###############################
    def SAR(x,p,s,predict_x_n=0):
        x = np.array(x[p*s:]).ravel()
        df0 = x.copy()
        Y = x[s*p:].copy()
        h = len(x) - p*s
        X = np.zeros((h,p))
        for t in range(h):
            for i in range(1,p+1):
                X[t][-i] = x[p*s+t-i*s]
        sigma = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(Y.T)          #最小二乘法估计参数值
        for i in range(h):
            df0[p*s+i] = sum(np.multiply(sigma , X[i]))        #得到所有预测的估计值
        df00 = x.copy()
        df1 = np.zeros(predict_x_n)
        for i in range(predict_x_n):
            df1[i] = sum(np.multiply(sigma , df00[-p:][::-1]))        #得到所有预测值
            df00 = np.append(df00,df1[i])
        return df0,df1,sigma
    wucha,wucha_predict,sigma = SAR(df_wu,q,s,predict_x_n)
    return wucha,wucha_predict,sigma
def SARIMA(p,q,P,Q,data,m):
    #p_aicc,p_bic = p_finally(10)
    df0,df1,sigma = AR_prediction(data,p,0)
    wucha,wucha_predict,sigma1,df_wu = MA_prediction(data, q, 0)
    a,b,sigma2 = SAR(data,P,m,0)
    c,d,sigma3 = SMA(data,Q,m,0)
    sigma = sigma[::-1]
    sigma1 = sigma1[::-1]
    sigma2 = sigma2[::-1]
    sigma3 = sigma3[::-1]
    sigma22 = np.append(np.array([1]),sigma2)
    sigma33 = np.append(np.array([1]),sigma3)
    result = []
    for t in range(30,len(data)+1):
        sar = 0
        for p in range(p):
            for P in range(P+1):
                sar += sigma[p] * data[t-p-1-P*m] * sigma22[P]
        sar += sum(sigma2 * np.array([data[t-i*m] for i in range(1,P+1)]))
        sma = 0
        for q in range(q):
            for Q in range(Q+1):
                sma += sigma1[q] * df_wu[t-q-1-Q*m] * sigma33[Q]
        sma += sum(sigma3 * np.array([df_wu[t-i*m] for i in range(1,Q+1)]))
        result.append(sar + sma)
    return result


data0 = pd.read_csv('时间序列预测数据集.csv',parse_dates=['Date'])
data0.set_index('Date',inplace=True)     #将时间设置为行索引
data=np.array(copy.deepcopy(data0)).ravel()
#data = data.reshape((10,365))    #季节性差分
#data=np.diff(data,1)
#data = data.ravel()
result = SARIMA(6,7,2,2,data,365)
plt.figure(figsize=(15, 7.5))
plt.plot(range(500),data[-500:],c = 'black',label='actual')
plt.plot(range(500),result[-500:],c='red',label='model')
plt.show()

print('mse:',mean_squared_error(result,data[-len(result):]))

数学建模
SARIMA预测代码
https://jimes.cn/2024/09/11/SARIMA预测/
作者
Jimes
发布于
2024年9月11日
许可协议
+ + \ No newline at end of file diff --git "a/2024/09/11/\344\272\244\351\200\232\350\277\220\350\276\223\345\267\245\347\250\213\345\255\246\350\257\276\347\250\213\350\256\276\350\256\241\344\273\243\347\240\201/index.html" "b/2024/09/11/\344\272\244\351\200\232\350\277\220\350\276\223\345\267\245\347\250\213\345\255\246\350\257\276\347\250\213\350\256\276\350\256\241\344\273\243\347\240\201/index.html" index 641b499..eb92ad6 100644 --- "a/2024/09/11/\344\272\244\351\200\232\350\277\220\350\276\223\345\267\245\347\250\213\345\255\246\350\257\276\347\250\213\350\256\276\350\256\241\344\273\243\347\240\201/index.html" +++ "b/2024/09/11/\344\272\244\351\200\232\350\277\220\350\276\223\345\267\245\347\250\213\345\255\246\350\257\276\347\250\213\350\256\276\350\256\241\344\273\243\347\240\201/index.html" @@ -1 +1,14 @@ -交通运输工程学课程设计代码 - 马锦的博客

交通运输工程学课程设计代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
import numpy as np
from numpy import random
from copy import deepcopy
import matplotlib.pyplot as plt
from tqdm import tqdm
import warnings
warnings.filterwarnings("ignore")
np.set_printoptions(threshold=np.inf) # threshold 指定超过多少使用省略号，np.inf代表无限大
np.set_printoptions(suppress=True) #不以科学计数法输出
plt.rcParams['axes.unicode_minus'] = False #显示负号
plt.rcParams['font.family'] = ['sans-serif']
plt.rcParams['font.sans-serif'] = ['SimHei']  # 散点图标签可以显示中文

def haversine_distance(coord1, coord2):
    # 将经纬度从度数转换为弧度
    lat1, lon1 = np.radians(coord1[1]), np.radians(coord1[0])
    lat2, lon2 = np.radians(coord2[1]), np.radians(coord2[0])
    # Haversine 公式
    dlon = lon2 - lon1
    dlat = lat2 - lat1
    a = np.sin(dlat / 2) ** 2 + np.cos(lat1) * np.cos(lat2) * np.sin(dlon / 2) ** 2
    c = 2 * np.arctan2(np.sqrt(a), np.sqrt(1 - a))
    # 地球半径（单位：公里）
    radius = 6371.0
    # 计算距离
    distance = radius * c
    return distance
coordinates = np.array([
    [104.107895, 30.457623],
    [104.642054, 30.702534],
    [104.055628, 30.527435],
    [103.721549, 30.931824],
    [104.112324, 30.668907],
    [104.077094, 30.674277],
    [104.214562, 30.531782],
    [103.943217, 30.782159],
    [104.145552, 30.605267],
    [104.028378, 30.676363],
    [103.974325, 30.735671],
    [104.076092, 30.624577],
    [104.060045, 30.633286],
    [104.042753, 30.637203],
    [104.034653, 30.525472],
    [103.922376, 30.570071],
    [103.693276, 30.632171],
    [104.101776, 30.632171],
    [104.234756, 30.568442],
    [104.074576, 30.624871],
    [104.204776, 30.518071]
])
# 初始化距离矩阵
num_points = len(coordinates)
dist_matrix = np.zeros((num_points, num_points))
# 计算距离矩阵
for i in range(num_points):
    for j in range(num_points):
        dist_matrix[i, j] = haversine_distance(coordinates[i], coordinates[j])
values = [0, 1.151, 1.273, 1.512, 2.311, 0.827, 4.185, 2.342, 1.124, 1.367, 4.227,
          0.622, 0.937, 1.722, 3.075, 1.252, 5.221, 2.879, 2.357, 4.212, 3.661]
# 46t

def xuhao(x,v):  # 获取x中第v个1的纵坐标
    vv = 0
    for i in range(len(x)):
        if x[i] == 1:
            vv += 1
            if vv == v:
                return i
def dfs(graph, start, end, k, matrix):
    xx = []
    dd = [0]*k
    for i in range(k):
        xxx = [start]
        down = xuhao(graph[start],i+1)
        dd[i] += float(matrix[start,down])
        start = down
        xxx.append(start)
        while start != end:
            down = xuhao(graph[start],1)
            dd[i] += matrix[start][down]
            xxx.append(down)
            start = down
        xx.append(xxx)
    vv = [0]*k
    for i in range(len(xx)):
        for j in range(1,len(xx[i])-1):
            vv[i] += values[xx[i][j]]
    return xx,dd,vv


def xijdef(x):
    xij = np.zeros((21,21), dtype=int)
    # 将主对角线上面的一条线设为1
    for i in range(1,21-x):
        xij[i, i+x] = 1
    for i in range(1,x+1):
        xij[-i,0] = 1
    for i in range(1,x+1):
        xij[0,i] = 1
    return xij

def fun(X):  # 目标函数和约束条件
    x = X.flatten() #将X变为一维数组
    xij = xijdef(int(x[-1]))
    for i in range(15):
        xij[:,int(x[2*i])] , xij[:,int(x[2*i+1])] = xij[:,int(x[2*i+1])].copy() , xij[:,int(x[2*i])].copy()
    for i in range(15,30):
        xij[int(x[2*i]),:] , xij[int(x[2*i+1]),:] = xij[int(x[2*i+1]),:].copy() , xij[int(x[2*i]),:].copy()
    result,dd,vv = dfs(xij,0,0,int(x[-1]),dist_matrix)  # 获得路径与路程

    st = 0
    lis = [element for sublist in result for element in sublist if element != 0]
    if len(lis) != 20:
        st += 1000000000000
    if max(dd) > 150: # 最大距离限制
        st += 1000000000
    if max(vv) > 10: # 最大容量限制
        st += 1000000000
    for i in range(1,21): # 每个点都要走
        if sum(xij[:,i]) != 1:
            st += 1000000000
        if sum(xij[i,:]) != 1:
            st += 1000000000

    for i in range(21):  # 避免车辆来回跑
        for j in range(i+1):
            if xij[i,j] == xij[j,i] and xij[i,j] == 1:
                st += 1000000000

    fx1 = x[-1]*150  # 车辆固定成本
    fx2 = 0
    fx3 = 0
    e = np.e
    for i in range(len(result)):
        ddd = 0
        for j in range(1,len(result[i])):
            ddd += dist_matrix[result[i][j-1],result[i][j]]
            if j == len(result[i])-1:
                fx3 += 6*dist_matrix[result[i][j-1],result[i][j]]
            else:
                fx2 += (1-1/e**(0.05*(ddd/23)))*500*values[result[i][j]] # 货损成本
                fx3 += ddd*7*values[result[i][j]] # 运输费用
    return fx1+fx2+fx3+st


def dd2(best_x, x):  #欧氏距离
    best_x = np.array(best_x)   #转化成numpy数组
    x = np.array(x)          #转化成numpy数组
    c = np.sum(pow(x - best_x, 2), axis=1)    #求方差，在行上的标准差
    d = pow(c, 0.5)   #标准差
    return d
def new_min(arr):  #求最小
    min_data = min(arr)   #找到最小值
    key = np.argmin(arr)  #找到最小值的索引
    return min_data, key
def type_x(xx,type,n):  #变量范围约束
    for v in range(n):
        if type[v] == -1:
            xx[v] = np.maximum(sub[v], xx[v])
            xx[v] = np.minimum(up[v], xx[v])
        elif type[v] == 0:
            xx[v] = np.maximum(sub[v], int(xx[v]))
            xx[v] = np.minimum(up[v], int(xx[v]))
        else:
            xx[v] = np.maximum(sub[v], random.randint(0,2))
            xx[v] = np.minimum(up[v], random.randint(0,2))
    return xx
def woa(sub,up,type,nums,det):
    n = len(sub)  # 自变量个数
    num = nums * n  # 种群大小
    x = np.zeros([num, n])  #生成保存解的矩阵

    f = np.zeros(num)   #生成保存值的矩阵
    for s in range(num):      #随机生成初始解
        for v in range(n):
            rand_data = np.random.uniform(0,1)
            x[s, v] = sub[v] + (up[v] - sub[v]) * rand_data
        x[s, :] = type_x(x[s, :],type,n)
        f[s] = fun(x[s, :])
    best_f, a = new_min(f)  # 记录历史最优值
    best_x = x[a, :]  # 记录历史最优解
    trace = np.array([deepcopy(best_f)]) #记录初始最优值,以便后期添加最优值画图
    ############################ 改进的鲸鱼算法 ################################
    xx = np.zeros([num, n])
    ff = np.zeros(num)
    Mc = (up - sub) * 0.1  # 猎物行动最大范围
    for ii in tqdm(range(det)):      #设置迭代次数，进入迭代过程
        # 猎物躲避,蒙特卡洛模拟，并选择最佳的点作为下一逃跑点 #########！！！创新点
        d = dd2(best_x, x)  #记录当前解与最优解的距离
        d.sort()  #从小到大排序,d[0]恒为0
        z = np.exp(-d[1] / np.mean(Mc))  # 猎物急躁系数
        z = max(z, 0.1)     #决定最终系数
        yx = []  #初始化存储函数值
        dx = []  #初始化存储解
        random_rand = random.random() #0-1的随机数
        for i in range(30):    #蒙特卡洛模拟的次数
            m = [random.choice([-1, 1]) for _ in range(n)] #随机的-1和1
            asd = best_x + Mc * z * ((det-ii )/det) * random_rand * m   #最优解更新公式
            xd = type_x(asd,type,n)  #对自变量进行限制
            if i < 1:
                dx = deepcopy(xd)
            else:
                dx = np.vstack((dx,xd))   #存储每一次的解
            yx=np.hstack((yx,fun(xd)))    #存储每一次的值
        best_t, a = new_min(yx)  # 选择最佳逃跑点
        best_c = dx[a, :]   #最佳逃跑点
        if best_t < best_f:   #与鲸鱼算法得到的最优值对比
            best_f = best_t   #更新最优值
            best_x = best_c   #更新最优解
        ############################# 鲸鱼追捕 #################################
        w = (ii / det)**3   #自适应惯性权重!!!创新点
        a = (2 - 2*ii/det)*(1- w)  #a随迭代次数从2非线性下降至0！！！创新点
        pp=0.7 if ii <= 0.5*det else 0.4
        for i in range(num):
            r1 = np.random.rand()  # r1为[0,1]之间的随机数
            r2 = np.random.rand()  # r2为[0,1]之间的随机数
            A = 2 * a * r1 - a
            C = 2 * r2
            b = 1     #螺旋形状系数
            l = np.random.uniform(-1,1)  #参数l
            p = np.random.rand()
            if p < pp:
                if abs(A) >= 1:
                    rand_leader = np.random.randint(0, num)
                    X_rand = x[rand_leader, :]
                    D_X_rand = abs(C * X_rand - x[i, :])
                    xx[i, :] = w*X_rand - A * D_X_rand
                    xx[i, :] = type_x(xx[i, :],type,n) #对自变量进行限制
                elif abs(A) < 1:
                    D_Leader = abs(C * best_x - x[i, :])
                    xx[i, :] = w*best_x - A * D_Leader
                    xx[i, :] = type_x(xx[i, :],type,n) #对自变量进行限制
            elif p >= pp:
                D = abs(best_x - x[i, :])
                xx[i, :] = D*np.exp(b*l)*np.cos(2*np.pi*l) + (1-w)*best_x   #完整的气泡网捕食公式
                xx[i, :] = type_x(xx[i, :],type,n) #对自变量进行限制
            ff[i] = fun(xx[i, :])
            if len(np.unique(ff[:i]))/(i+1) <= 0.1:     #limit阈值 + 随机差分变异！！！创新点
                xx[i,:] = (r1*(best_x-xx[i,:]) +
                           r2*(x[np.random.randint(0,num),:] - xx[i,:]))
                xx[i, :] = type_x(xx[i, :],type,n) #对自变量进行限制
                ff[i] = fun(xx[i, :])
        #将上一代种群与这一代种群以及最优种群结合，选取排名靠前的个体组成新的种群
        F = np.hstack((np.array([best_f]), f, ff))
        F, b = np.sort(F,axis=-1,kind='stable'), np.argsort(F)#按小到大排序,获得靠前的位置
        X = np.vstack(([best_x], x, xx))[b, :]
        f = F[:num]  #新种群的位置
        x = X[:num, :]  #新种群的位置
        best_f, a = new_min(f)  # 记录历史最优值
        best_x = x[a , :]  # 记录历史最优解
        trace = np.hstack((trace, [best_f]))
    return best_x,best_f,trace


s = np.zeros((1,60))
sub = np.concatenate((s+1,np.array([[5]])), axis=1).ravel()  # 自变量下限
up = np.concatenate((s+20,np.array([[7]])), axis=1).ravel()  # 自变量上限
type = np.concatenate((s,np.array([[0]])), axis=1).ravel()    #-1是有理数，0是整数，1是0-1变量
best_x,best_f,trace = woa(sub,up,type,40,10)     #种群大小，迭代次数
#种群大小可以为自变量个数，迭代次数看情况
print('最优解为：')
print(best_x)
print('最优值为：')
print(float(best_f))

xij = xijdef(int(best_x[-1]))
for i in range(15):
    xij[:,int(best_x[2*i])] , xij[:,int(best_x[2*i+1])] = xij[:,int(best_x[2*i+1])].copy() , xij[:,int(best_x[2*i])].copy()
for i in range(15,30):
    xij[int(best_x[2*i])] , xij[int(best_x[2*i+1])] = xij[int(best_x[2*i+1])].copy() , xij[int(best_x[2*i])].copy()
result,dd,vv = dfs(xij,0,0,int(best_x[-1]),dist_matrix)
print(result)
print(dd)
print(vv)
fx1 = best_x[-1]*150  # 车辆固定成本
fx2 = 0
fx3 = 0
e = np.e
for i in range(len(result)):
    ddd = 0
    for j in range(1,len(result[i])):
        ddd += dist_matrix[result[i][j-1],result[i][j]]
        if j == len(result[i])-1:
            fx3 += 4*dist_matrix[result[i][j-1],result[i][j]]
        else:
            fx2 += (1-1/e**(0.05*(ddd/23)))*500*values[result[i][j]] # 货损成本
            fx3 += ddd*7*values[result[i][j]] # 运输费用
print(fx1,fx2,fx3)

plt.title('鲸鱼算法')
plt.plot(range(1,len(trace)+1),trace, color='r')
plt.show()
数学建模
交通运输工程学课程设计代码
https://jimes.cn/2024/09/11/交通运输工程学课程设计代码/
作者
Jimes
发布于
2024年9月11日
许可协议
\ No newline at end of file +交通运输工程学课程设计代码 - 马锦的博客

交通运输工程学课程设计代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
import numpy as np
from numpy import random
from copy import deepcopy
import matplotlib.pyplot as plt
from tqdm import tqdm
import warnings
warnings.filterwarnings("ignore")
np.set_printoptions(threshold=np.inf) # threshold 指定超过多少使用省略号，np.inf代表无限大
np.set_printoptions(suppress=True) #不以科学计数法输出
plt.rcParams['axes.unicode_minus'] = False #显示负号
plt.rcParams['font.family'] = ['sans-serif']
plt.rcParams['font.sans-serif'] = ['SimHei']  # 散点图标签可以显示中文

def haversine_distance(coord1, coord2):
    # 将经纬度从度数转换为弧度
    lat1, lon1 = np.radians(coord1[1]), np.radians(coord1[0])
    lat2, lon2 = np.radians(coord2[1]), np.radians(coord2[0])
    # Haversine 公式
    dlon = lon2 - lon1
    dlat = lat2 - lat1
    a = np.sin(dlat / 2) ** 2 + np.cos(lat1) * np.cos(lat2) * np.sin(dlon / 2) ** 2
    c = 2 * np.arctan2(np.sqrt(a), np.sqrt(1 - a))
    # 地球半径（单位：公里）
    radius = 6371.0
    # 计算距离
    distance = radius * c
    return distance
coordinates = np.array([
    [104.107895, 30.457623],
    [104.642054, 30.702534],
    [104.055628, 30.527435],
    [103.721549, 30.931824],
    [104.112324, 30.668907],
    [104.077094, 30.674277],
    [104.214562, 30.531782],
    [103.943217, 30.782159],
    [104.145552, 30.605267],
    [104.028378, 30.676363],
    [103.974325, 30.735671],
    [104.076092, 30.624577],
    [104.060045, 30.633286],
    [104.042753, 30.637203],
    [104.034653, 30.525472],
    [103.922376, 30.570071],
    [103.693276, 30.632171],
    [104.101776, 30.632171],
    [104.234756, 30.568442],
    [104.074576, 30.624871],
    [104.204776, 30.518071]
])
# 初始化距离矩阵
num_points = len(coordinates)
dist_matrix = np.zeros((num_points, num_points))
# 计算距离矩阵
for i in range(num_points):
    for j in range(num_points):
        dist_matrix[i, j] = haversine_distance(coordinates[i], coordinates[j])
values = [0, 1.151, 1.273, 1.512, 2.311, 0.827, 4.185, 2.342, 1.124, 1.367, 4.227,
          0.622, 0.937, 1.722, 3.075, 1.252, 5.221, 2.879, 2.357, 4.212, 3.661]
# 46t

def xuhao(x,v):  # 获取x中第v个1的纵坐标
    vv = 0
    for i in range(len(x)):
        if x[i] == 1:
            vv += 1
            if vv == v:
                return i
def dfs(graph, start, end, k, matrix):
    xx = []
    dd = [0]*k
    for i in range(k):
        xxx = [start]
        down = xuhao(graph[start],i+1)
        dd[i] += float(matrix[start,down])
        start = down
        xxx.append(start)
        while start != end:
            down = xuhao(graph[start],1)
            dd[i] += matrix[start][down]
            xxx.append(down)
            start = down
        xx.append(xxx)
    vv = [0]*k
    for i in range(len(xx)):
        for j in range(1,len(xx[i])-1):
            vv[i] += values[xx[i][j]]
    return xx,dd,vv


def xijdef(x):
    xij = np.zeros((21,21), dtype=int)
    # 将主对角线上面的一条线设为1
    for i in range(1,21-x):
        xij[i, i+x] = 1
    for i in range(1,x+1):
        xij[-i,0] = 1
    for i in range(1,x+1):
        xij[0,i] = 1
    return xij

def fun(X):  # 目标函数和约束条件
    x = X.flatten() #将X变为一维数组
    xij = xijdef(int(x[-1]))
    for i in range(15):
        xij[:,int(x[2*i])] , xij[:,int(x[2*i+1])] = xij[:,int(x[2*i+1])].copy() , xij[:,int(x[2*i])].copy()
    for i in range(15,30):
        xij[int(x[2*i]),:] , xij[int(x[2*i+1]),:] = xij[int(x[2*i+1]),:].copy() , xij[int(x[2*i]),:].copy()
    result,dd,vv = dfs(xij,0,0,int(x[-1]),dist_matrix)  # 获得路径与路程

    st = 0
    lis = [element for sublist in result for element in sublist if element != 0]
    if len(lis) != 20:
        st += 1000000000000
    if max(dd) > 150: # 最大距离限制
        st += 1000000000
    if max(vv) > 10: # 最大容量限制
        st += 1000000000
    for i in range(1,21): # 每个点都要走
        if sum(xij[:,i]) != 1:
            st += 1000000000
        if sum(xij[i,:]) != 1:
            st += 1000000000

    for i in range(21):  # 避免车辆来回跑
        for j in range(i+1):
            if xij[i,j] == xij[j,i] and xij[i,j] == 1:
                st += 1000000000

    fx1 = x[-1]*150  # 车辆固定成本
    fx2 = 0
    fx3 = 0
    e = np.e
    for i in range(len(result)):
        ddd = 0
        for j in range(1,len(result[i])):
            ddd += dist_matrix[result[i][j-1],result[i][j]]
            if j == len(result[i])-1:
                fx3 += 6*dist_matrix[result[i][j-1],result[i][j]]
            else:
                fx2 += (1-1/e**(0.05*(ddd/23)))*500*values[result[i][j]] # 货损成本
                fx3 += ddd*7*values[result[i][j]] # 运输费用
    return fx1+fx2+fx3+st


def dd2(best_x, x):  #欧氏距离
    best_x = np.array(best_x)   #转化成numpy数组
    x = np.array(x)          #转化成numpy数组
    c = np.sum(pow(x - best_x, 2), axis=1)    #求方差，在行上的标准差
    d = pow(c, 0.5)   #标准差
    return d
def new_min(arr):  #求最小
    min_data = min(arr)   #找到最小值
    key = np.argmin(arr)  #找到最小值的索引
    return min_data, key
def type_x(xx,type,n):  #变量范围约束
    for v in range(n):
        if type[v] == -1:
            xx[v] = np.maximum(sub[v], xx[v])
            xx[v] = np.minimum(up[v], xx[v])
        elif type[v] == 0:
            xx[v] = np.maximum(sub[v], int(xx[v]))
            xx[v] = np.minimum(up[v], int(xx[v]))
        else:
            xx[v] = np.maximum(sub[v], random.randint(0,2))
            xx[v] = np.minimum(up[v], random.randint(0,2))
    return xx
def woa(sub,up,type,nums,det):
    n = len(sub)  # 自变量个数
    num = nums * n  # 种群大小
    x = np.zeros([num, n])  #生成保存解的矩阵

    f = np.zeros(num)   #生成保存值的矩阵
    for s in range(num):      #随机生成初始解
        for v in range(n):
            rand_data = np.random.uniform(0,1)
            x[s, v] = sub[v] + (up[v] - sub[v]) * rand_data
        x[s, :] = type_x(x[s, :],type,n)
        f[s] = fun(x[s, :])
    best_f, a = new_min(f)  # 记录历史最优值
    best_x = x[a, :]  # 记录历史最优解
    trace = np.array([deepcopy(best_f)]) #记录初始最优值,以便后期添加最优值画图
    ############################ 改进的鲸鱼算法 ################################
    xx = np.zeros([num, n])
    ff = np.zeros(num)
    Mc = (up - sub) * 0.1  # 猎物行动最大范围
    for ii in tqdm(range(det)):      #设置迭代次数，进入迭代过程
        # 猎物躲避,蒙特卡洛模拟，并选择最佳的点作为下一逃跑点 #########！！！创新点
        d = dd2(best_x, x)  #记录当前解与最优解的距离
        d.sort()  #从小到大排序,d[0]恒为0
        z = np.exp(-d[1] / np.mean(Mc))  # 猎物急躁系数
        z = max(z, 0.1)     #决定最终系数
        yx = []  #初始化存储函数值
        dx = []  #初始化存储解
        random_rand = random.random() #0-1的随机数
        for i in range(30):    #蒙特卡洛模拟的次数
            m = [random.choice([-1, 1]) for _ in range(n)] #随机的-1和1
            asd = best_x + Mc * z * ((det-ii )/det) * random_rand * m   #最优解更新公式
            xd = type_x(asd,type,n)  #对自变量进行限制
            if i < 1:
                dx = deepcopy(xd)
            else:
                dx = np.vstack((dx,xd))   #存储每一次的解
            yx=np.hstack((yx,fun(xd)))    #存储每一次的值
        best_t, a = new_min(yx)  # 选择最佳逃跑点
        best_c = dx[a, :]   #最佳逃跑点
        if best_t < best_f:   #与鲸鱼算法得到的最优值对比
            best_f = best_t   #更新最优值
            best_x = best_c   #更新最优解
        ############################# 鲸鱼追捕 #################################
        w = (ii / det)**3   #自适应惯性权重!!!创新点
        a = (2 - 2*ii/det)*(1- w)  #a随迭代次数从2非线性下降至0！！！创新点
        pp=0.7 if ii <= 0.5*det else 0.4
        for i in range(num):
            r1 = np.random.rand()  # r1为[0,1]之间的随机数
            r2 = np.random.rand()  # r2为[0,1]之间的随机数
            A = 2 * a * r1 - a
            C = 2 * r2
            b = 1     #螺旋形状系数
            l = np.random.uniform(-1,1)  #参数l
            p = np.random.rand()
            if p < pp:
                if abs(A) >= 1:
                    rand_leader = np.random.randint(0, num)
                    X_rand = x[rand_leader, :]
                    D_X_rand = abs(C * X_rand - x[i, :])
                    xx[i, :] = w*X_rand - A * D_X_rand
                    xx[i, :] = type_x(xx[i, :],type,n) #对自变量进行限制
                elif abs(A) < 1:
                    D_Leader = abs(C * best_x - x[i, :])
                    xx[i, :] = w*best_x - A * D_Leader
                    xx[i, :] = type_x(xx[i, :],type,n) #对自变量进行限制
            elif p >= pp:
                D = abs(best_x - x[i, :])
                xx[i, :] = D*np.exp(b*l)*np.cos(2*np.pi*l) + (1-w)*best_x   #完整的气泡网捕食公式
                xx[i, :] = type_x(xx[i, :],type,n) #对自变量进行限制
            ff[i] = fun(xx[i, :])
            if len(np.unique(ff[:i]))/(i+1) <= 0.1:     #limit阈值 + 随机差分变异！！！创新点
                xx[i,:] = (r1*(best_x-xx[i,:]) +
                           r2*(x[np.random.randint(0,num),:] - xx[i,:]))
                xx[i, :] = type_x(xx[i, :],type,n) #对自变量进行限制
                ff[i] = fun(xx[i, :])
        #将上一代种群与这一代种群以及最优种群结合，选取排名靠前的个体组成新的种群
        F = np.hstack((np.array([best_f]), f, ff))
        F, b = np.sort(F,axis=-1,kind='stable'), np.argsort(F)#按小到大排序,获得靠前的位置
        X = np.vstack(([best_x], x, xx))[b, :]
        f = F[:num]  #新种群的位置
        x = X[:num, :]  #新种群的位置
        best_f, a = new_min(f)  # 记录历史最优值
        best_x = x[a , :]  # 记录历史最优解
        trace = np.hstack((trace, [best_f]))
    return best_x,best_f,trace


s = np.zeros((1,60))
sub = np.concatenate((s+1,np.array([[5]])), axis=1).ravel()  # 自变量下限
up = np.concatenate((s+20,np.array([[7]])), axis=1).ravel()  # 自变量上限
type = np.concatenate((s,np.array([[0]])), axis=1).ravel()    #-1是有理数，0是整数，1是0-1变量
best_x,best_f,trace = woa(sub,up,type,40,10)     #种群大小，迭代次数
#种群大小可以为自变量个数，迭代次数看情况
print('最优解为：')
print(best_x)
print('最优值为：')
print(float(best_f))

xij = xijdef(int(best_x[-1]))
for i in range(15):
    xij[:,int(best_x[2*i])] , xij[:,int(best_x[2*i+1])] = xij[:,int(best_x[2*i+1])].copy() , xij[:,int(best_x[2*i])].copy()
for i in range(15,30):
    xij[int(best_x[2*i])] , xij[int(best_x[2*i+1])] = xij[int(best_x[2*i+1])].copy() , xij[int(best_x[2*i])].copy()
result,dd,vv = dfs(xij,0,0,int(best_x[-1]),dist_matrix)
print(result)
print(dd)
print(vv)
fx1 = best_x[-1]*150  # 车辆固定成本
fx2 = 0
fx3 = 0
e = np.e
for i in range(len(result)):
    ddd = 0
    for j in range(1,len(result[i])):
        ddd += dist_matrix[result[i][j-1],result[i][j]]
        if j == len(result[i])-1:
            fx3 += 4*dist_matrix[result[i][j-1],result[i][j]]
        else:
            fx2 += (1-1/e**(0.05*(ddd/23)))*500*values[result[i][j]] # 货损成本
            fx3 += ddd*7*values[result[i][j]] # 运输费用
print(fx1,fx2,fx3)

plt.title('鲸鱼算法')
plt.plot(range(1,len(trace)+1),trace, color='r')
plt.show()
数学建模
交通运输工程学课程设计代码
https://jimes.cn/2024/09/11/交通运输工程学课程设计代码/
作者
Jimes
发布于
2024年9月11日
许可协议
+ + \ No newline at end of file diff --git "a/2024/09/11/\346\216\222\351\230\237\350\256\272\346\250\241\345\236\213\344\273\243\347\240\201/index.html" "b/2024/09/11/\346\216\222\351\230\237\350\256\272\346\250\241\345\236\213\344\273\243\347\240\201/index.html" index b028d68..d4689b3 100644 --- "a/2024/09/11/\346\216\222\351\230\237\350\256\272\346\250\241\345\236\213\344\273\243\347\240\201/index.html" +++ "b/2024/09/11/\346\216\222\351\230\237\350\256\272\346\250\241\345\236\213\344\273\243\347\240\201/index.html" @@ -1 +1,14 @@ -排队论模型代码 - 马锦的博客

排队论模型代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
import math

def mm1_model(lamb_da, miu, n=0):
    rou = lamb_da / miu
    W_s = 1 / (miu - lamb_da)
    W_q = rou / (miu - lamb_da)
    L_s = lamb_da * W_s
    L_q = lamb_da * W_q
    P_n = (1-rou)*(rou**n)
    return {
        '服务强度': rou,
        '平均队长': L_s,
        '平均队列长': L_q,
        '平均逗留时间': W_s,
        '平均等待时间': W_q,
        f'系统稳定有{n}个顾客的概率':P_n
    }
def mm1N_model(lamb_da, miu, N, n=0):
    '''
    损失制:当顾客到达时，队列达到N，顾客随即离去。
    '''
    rou = lamb_da / miu
    P_N = (1-rou)*(rou**N)/(1-rou**(N+1))
    lamb_da_e = lamb_da*(1-P_N)
    rou_e = lamb_da_e / miu
    L_s = 1/(1-rou) - ((N+1)*rou**(N+1))/(1-rou**(N+1))
    L_q = L_s - rou_e
    W_s = L_s/lamb_da_e
    W_q = L_q/lamb_da_e
    P_n = (1-rou)*(rou**n)/(1-rou**(N+1))
    return {
        '有效服务强度': rou_e,
        '平均队长': L_s,
        '平均队列长': L_q,
        '平均逗留时间': W_s,
        '平均等待时间': W_q,
        f'系统稳定有{n}个顾客的概率':P_n
    }
def mm1_m_model(lamb_da, miu, m, n=0):
    '''
    这里的lamb_da定义为每个顾客的到达率
    '''
    rou = lamb_da / miu
    P_0 = 1/sum(math.factorial(m)/math.factorial(m-i)*rou**i
                for i in range(0,m+1))
    W_s = m/(miu*(1-P_0)) - 1/lamb_da
    W_q = W_s - 1/miu
    L_s = m - (miu/lamb_da)*(1-P_0)
    L_q = L_s - (1-P_0)
    if n == 0:
        P_n = P_0
    else:
        P_n = math.factorial(m)/math.factorial(m-n)*rou**n * P_0
    return {
        '服务强度': rou,
        '平均队长': L_s,
        '平均队列长': L_q,
        '平均逗留时间': W_s,
        '平均等待时间': W_q,
        f'系统稳定有{n}个顾客的概率':P_n
    }
def mmc_model(lamb_da, miu, c, n=0):
    rou = lamb_da / (miu*c)
    P_0 = 1/(sum(1/math.factorial(i)*(rou*c)**i
                for i in range(0,c-1))
             +1/(math.factorial(c)*(1-rou))*(rou*c)**c)
    L_q = P_0*(rou*c)**c*rou/(math.factorial(c)*(1+rou)**2)
    L_s = L_q + rou*c
    W_s = L_s / lamb_da
    W_q = L_q / lamb_da
    if n == 0:
        P_n = P_0
    elif n<=c:
        P_n = P_0*(rou*c)**n / math.factorial(n)
    else:
        P_n = P_0*(rou*c)**n / (math.factorial(c)*c**(n-c))
    return {
        '服务强度': rou,
        '平均队长': L_s,
        '平均队列长': L_q,
        '平均逗留时间': W_s,
        '平均等待时间': W_q,
        f'系统稳定有{n}个顾客的概率':P_n
    }
def mmcN_model(lamb_da, miu, c, N, n=0):
    rou = lamb_da / (miu*c)
    if rou == 1:
        P_0 = sum(c**i/math.factorial(i) for i in range(0,c))\
             +(N-c+1)*c**c/math.factorial(c)
    else:
        P_0 =1/(sum(c*rou**i/math.factorial(i) for i in range(0,c))\
                +(rou*(rou**c-rou**N)/(1-rou))*c**c/math.factorial(c))
    if n<=c:
        P_n = P_0*(rou*c)**n / math.factorial(n)
    elif n>c and n<=N:
        P_n = P_0 * c**c * rou**n / math.factorial(c)
    L_q = 0
    P_N = P_0 * c**c * rou**N / math.factorial(c)
    for i in range(1,N-c+1):
        L_q += i*P_N
    L_s = L_q + rou*c*(1-P_N)
    W_q = L_q / (lamb_da*(1-P_N))
    W_s = W_q + 1/miu
    return {
        '服务强度': rou,
        '平均队长': L_s,
        '平均队列长': L_q,
        '平均逗留时间': W_s,
        '平均等待时间': W_q,
        f'系统稳定有{n}个顾客的概率': P_n
    }
def mmc_m_model(lamb_da, miu, c, m, n=0):
    '''
    n应该要大于c，不然概率可能大于1.
    因为有时每个服务台都会有人。
    '''
    rou = m*lamb_da / (miu*c)
    P_0 =1/((sum((c*rou/m)**i/(math.factorial(i)*math.factorial(m-i)) for i in range(0,c+1))\
            +sum(c**c*(rou/m)**i/(math.factorial(m-i)*math.factorial(c)) for i in range(0,c+1)))\
            *math.factorial(m))
    def P(P_0, lamb_da, miu, c, m, n=0):
        if n<=c:
            P_n = (P_0*((lamb_da/miu)**n)*math.factorial(m) /
                   (math.factorial(n)*math.factorial(m-n)))
        elif n>c and n<=m:
            P_n = (P_0*(lamb_da/miu)**n*math.factorial(m) /
                   (math.factorial(c)*math.factorial(m-n)*c**(n-c)))
        return P_n
    P_n = P(P_0, lamb_da, miu, c, m, n)
    L_q = sum(i*P(P_0, lamb_da, miu, c, m, i) for i in range(1,m-c+1))
    L_s = sum(i*P(P_0, lamb_da, miu, c, m, i) for i in range(1,m+1))
    lamb_da_e = lamb_da * (m-L_s)
    W_s = L_s/lamb_da_e
    W_q = L_q/lamb_da_e
    return {
        '服务强度': rou,
        '平均队长': L_s,
        '平均队列长': L_q,
        '平均逗留时间': W_s,
        '平均等待时间': W_q,
        f'系统稳定有{n}个顾客的概率': P_n
    }
# 输入模拟参数
lamb_da = 0.8  # 平均到达速率
miu = 0.6  # 平均服务速率
c = 10  # 服务台数量 ,需要小于m
N = 5  # 队列（排队）容量
m = 10  # 顾客源总数

results = mmc_m_model(lamb_da, miu, c, m, 5)
for key, value in results.items():
    print(f"{key}: {value:.6f}")

数学建模
排队论模型代码
https://jimes.cn/2024/09/11/排队论模型代码/
作者
Jimes
发布于
2024年9月11日
许可协议
\ No newline at end of file +排队论模型代码 - 马锦的博客

排队论模型代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
import math

def mm1_model(lamb_da, miu, n=0):
    rou = lamb_da / miu
    W_s = 1 / (miu - lamb_da)
    W_q = rou / (miu - lamb_da)
    L_s = lamb_da * W_s
    L_q = lamb_da * W_q
    P_n = (1-rou)*(rou**n)
    return {
        '服务强度': rou,
        '平均队长': L_s,
        '平均队列长': L_q,
        '平均逗留时间': W_s,
        '平均等待时间': W_q,
        f'系统稳定有{n}个顾客的概率':P_n
    }
def mm1N_model(lamb_da, miu, N, n=0):
    '''
    损失制:当顾客到达时，队列达到N，顾客随即离去。
    '''
    rou = lamb_da / miu
    P_N = (1-rou)*(rou**N)/(1-rou**(N+1))
    lamb_da_e = lamb_da*(1-P_N)
    rou_e = lamb_da_e / miu
    L_s = 1/(1-rou) - ((N+1)*rou**(N+1))/(1-rou**(N+1))
    L_q = L_s - rou_e
    W_s = L_s/lamb_da_e
    W_q = L_q/lamb_da_e
    P_n = (1-rou)*(rou**n)/(1-rou**(N+1))
    return {
        '有效服务强度': rou_e,
        '平均队长': L_s,
        '平均队列长': L_q,
        '平均逗留时间': W_s,
        '平均等待时间': W_q,
        f'系统稳定有{n}个顾客的概率':P_n
    }
def mm1_m_model(lamb_da, miu, m, n=0):
    '''
    这里的lamb_da定义为每个顾客的到达率
    '''
    rou = lamb_da / miu
    P_0 = 1/sum(math.factorial(m)/math.factorial(m-i)*rou**i
                for i in range(0,m+1))
    W_s = m/(miu*(1-P_0)) - 1/lamb_da
    W_q = W_s - 1/miu
    L_s = m - (miu/lamb_da)*(1-P_0)
    L_q = L_s - (1-P_0)
    if n == 0:
        P_n = P_0
    else:
        P_n = math.factorial(m)/math.factorial(m-n)*rou**n * P_0
    return {
        '服务强度': rou,
        '平均队长': L_s,
        '平均队列长': L_q,
        '平均逗留时间': W_s,
        '平均等待时间': W_q,
        f'系统稳定有{n}个顾客的概率':P_n
    }
def mmc_model(lamb_da, miu, c, n=0):
    rou = lamb_da / (miu*c)
    P_0 = 1/(sum(1/math.factorial(i)*(rou*c)**i
                for i in range(0,c-1))
             +1/(math.factorial(c)*(1-rou))*(rou*c)**c)
    L_q = P_0*(rou*c)**c*rou/(math.factorial(c)*(1+rou)**2)
    L_s = L_q + rou*c
    W_s = L_s / lamb_da
    W_q = L_q / lamb_da
    if n == 0:
        P_n = P_0
    elif n<=c:
        P_n = P_0*(rou*c)**n / math.factorial(n)
    else:
        P_n = P_0*(rou*c)**n / (math.factorial(c)*c**(n-c))
    return {
        '服务强度': rou,
        '平均队长': L_s,
        '平均队列长': L_q,
        '平均逗留时间': W_s,
        '平均等待时间': W_q,
        f'系统稳定有{n}个顾客的概率':P_n
    }
def mmcN_model(lamb_da, miu, c, N, n=0):
    rou = lamb_da / (miu*c)
    if rou == 1:
        P_0 = sum(c**i/math.factorial(i) for i in range(0,c))\
             +(N-c+1)*c**c/math.factorial(c)
    else:
        P_0 =1/(sum(c*rou**i/math.factorial(i) for i in range(0,c))\
                +(rou*(rou**c-rou**N)/(1-rou))*c**c/math.factorial(c))
    if n<=c:
        P_n = P_0*(rou*c)**n / math.factorial(n)
    elif n>c and n<=N:
        P_n = P_0 * c**c * rou**n / math.factorial(c)
    L_q = 0
    P_N = P_0 * c**c * rou**N / math.factorial(c)
    for i in range(1,N-c+1):
        L_q += i*P_N
    L_s = L_q + rou*c*(1-P_N)
    W_q = L_q / (lamb_da*(1-P_N))
    W_s = W_q + 1/miu
    return {
        '服务强度': rou,
        '平均队长': L_s,
        '平均队列长': L_q,
        '平均逗留时间': W_s,
        '平均等待时间': W_q,
        f'系统稳定有{n}个顾客的概率': P_n
    }
def mmc_m_model(lamb_da, miu, c, m, n=0):
    '''
    n应该要大于c，不然概率可能大于1.
    因为有时每个服务台都会有人。
    '''
    rou = m*lamb_da / (miu*c)
    P_0 =1/((sum((c*rou/m)**i/(math.factorial(i)*math.factorial(m-i)) for i in range(0,c+1))\
            +sum(c**c*(rou/m)**i/(math.factorial(m-i)*math.factorial(c)) for i in range(0,c+1)))\
            *math.factorial(m))
    def P(P_0, lamb_da, miu, c, m, n=0):
        if n<=c:
            P_n = (P_0*((lamb_da/miu)**n)*math.factorial(m) /
                   (math.factorial(n)*math.factorial(m-n)))
        elif n>c and n<=m:
            P_n = (P_0*(lamb_da/miu)**n*math.factorial(m) /
                   (math.factorial(c)*math.factorial(m-n)*c**(n-c)))
        return P_n
    P_n = P(P_0, lamb_da, miu, c, m, n)
    L_q = sum(i*P(P_0, lamb_da, miu, c, m, i) for i in range(1,m-c+1))
    L_s = sum(i*P(P_0, lamb_da, miu, c, m, i) for i in range(1,m+1))
    lamb_da_e = lamb_da * (m-L_s)
    W_s = L_s/lamb_da_e
    W_q = L_q/lamb_da_e
    return {
        '服务强度': rou,
        '平均队长': L_s,
        '平均队列长': L_q,
        '平均逗留时间': W_s,
        '平均等待时间': W_q,
        f'系统稳定有{n}个顾客的概率': P_n
    }
# 输入模拟参数
lamb_da = 0.8  # 平均到达速率
miu = 0.6  # 平均服务速率
c = 10  # 服务台数量 ,需要小于m
N = 5  # 队列（排队）容量
m = 10  # 顾客源总数

results = mmc_m_model(lamb_da, miu, c, m, 5)
for key, value in results.items():
    print(f"{key}: {value:.6f}")

数学建模
排队论模型代码
https://jimes.cn/2024/09/11/排队论模型代码/
作者
Jimes
发布于
2024年9月11日
许可协议
+ + \ No newline at end of file diff --git "a/2024/09/11/\346\224\271\350\277\233\347\232\204\351\262\270\351\261\274\347\256\227\346\263\225\344\273\243\347\240\201/index.html" "b/2024/09/11/\346\224\271\350\277\233\347\232\204\351\262\270\351\261\274\347\256\227\346\263\225\344\273\243\347\240\201/index.html" index fb97f37..26c91da 100644 --- "a/2024/09/11/\346\224\271\350\277\233\347\232\204\351\262\270\351\261\274\347\256\227\346\263\225\344\273\243\347\240\201/index.html" +++ "b/2024/09/11/\346\224\271\350\277\233\347\232\204\351\262\270\351\261\274\347\256\227\346\263\225\344\273\243\347\240\201/index.html" @@ -1 +1,14 @@ -改进的鲸鱼算法代码 - 马锦的博客

改进的鲸鱼算法代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
import numpy as np
from numpy import random
from copy import deepcopy
from tqdm import tqdm
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings("ignore")
np.set_printoptions(threshold=np.inf) # threshold 指定超过多少使用省略号，np.inf代表无限大
np.set_printoptions(suppress=True) #不以科学计数法输出
plt.rcParams['axes.unicode_minus'] = False #显示负号
plt.rcParams['font.family'] = ['sans-serif']
plt.rcParams['font.sans-serif'] = ['SimHei']  # 散点图标签可以显示中文
def fun(X):  # 目标函数和约束条件
    x = X.flatten() #将X变为一维数组
    fx = 0
    for i in range(len(x)-1):
        a = x[i]**2 - 10*np.cos(2*np.pi*x[i]) + 10
        fx += a
    fx += -7*x[-1]
    return fx      #施加惩罚项

s = np.zeros((1,30))
sub = np.array(s-10).ravel()  # 自变量下限
up = np.array(s+10).ravel()  # 自变量上限
type = np.array(s).ravel()    #-1是有理数，0是整数，1是0-1变量

def dd2(best_x, x):  #欧氏距离
    best_x = np.array(best_x)   #转化成numpy数组
    x = np.array(x)          #转化成numpy数组
    c = np.sum(pow(x - best_x, 2), axis=1)    #求方差，在行上的标准差
    d = pow(c, 0.5)   #标准差
    return d
def new_min(arr):  #求最小
    min_data = min(arr)   #找到最小值
    key = np.argmin(arr)  #找到最小值的索引
    return min_data, key
def type_x(xx,type,n):  #变量范围约束
    for v in range(n):
        if type[v] == -1:
            xx[v] = np.maximum(sub[v], xx[v])
            xx[v] = np.minimum(up[v], xx[v])
        elif type[v] == 0:
            xx[v] = np.maximum(sub[v], int(xx[v]))
            xx[v] = np.minimum(up[v], int(xx[v]))
        else:
            xx[v] = np.maximum(sub[v], random.randint(0,2))
            xx[v] = np.minimum(up[v], random.randint(0,2))
    return xx
def woa(sub,up,type,nums,det):
    n = len(sub)  # 自变量个数
    num = nums * n  # 种群大小
    x = np.zeros([num, n])  #生成保存解的矩阵
    f = np.zeros(num)   #生成保存值的矩阵
    for s in range(num):      #随机生成初始解
        for v in range(n):
            rand_data = np.random.uniform(0,1)
            x[s, v] = sub[v] + (up[v] - sub[v]) * rand_data
        x[s, :] = type_x(x[s, :],type,n)
        f[s] = fun(x[s, :])
    best_f, a = new_min(f)  # 记录历史最优值
    best_x = x[a, :]  # 记录历史最优解
    trace = np.array([deepcopy(best_f)]) #记录初始最优值,以便后期添加最优值画图
    ############################ 改进的鲸鱼算法 ################################
    xx = np.zeros([num, n])
    ff = np.zeros(num)
    Mc = (up - sub) * 0.1  # 猎物行动最大范围
    for ii in tqdm(range(det)):      #设置迭代次数，进入迭代过程
        # 猎物躲避,蒙特卡洛模拟，并选择最佳的点作为下一逃跑点 #########！！！创新点
        d = dd2(best_x, x)  #记录当前解与最优解的距离
        d.sort()  #从小到大排序,d[0]恒为0
        z = np.exp(-d[1] / np.mean(Mc))  # 猎物急躁系数
        z = max(z, 0.1)     #决定最终系数
        yx = []  #初始化存储函数值
        dx = []  #初始化存储解
        random_rand = random.random(n) #0-1的随机数
        for i in range(50):    #蒙特卡洛模拟的次数
            m = [random.choice([-1, 1]) for _ in range(n)] #随机的-1和1
            asd = best_x + Mc * z * ((det-ii )/det) * random_rand * m   #最优解更新公式
            xd = type_x(asd,type,n)  #对自变量进行限制
            if i < 1:
                dx = deepcopy(xd)
            else:
                dx = np.vstack((dx,xd))   #存储每一次的解
            yx=np.hstack((yx,fun(xd)))    #存储每一次的值
        best_t, a = new_min(yx)  # 选择最佳逃跑点
        best_c = dx[a, :]   #最佳逃跑点
        if best_t < best_f:   #与鲸鱼算法得到的最优值对比
            best_f = best_t   #更新最优值
            best_x = best_c   #更新最优解
        ############################# 鲸鱼追捕 #################################
        w = (ii / det)**3   #自适应惯性权重!!!创新点
        a = (2 - 2*ii/det)*(1- w)  #a随迭代次数从2非线性下降至0！！！创新点
        pp=0.7 if ii <= 0.5*det else 0.4
        for i in range(num):
            r1 = np.random.rand()  # r1为[0,1]之间的随机数
            r2 = np.random.rand()  # r2为[0,1]之间的随机数
            A = 2 * a * r1 - a
            C = 2 * r2
            b = 1     #螺旋形状系数
            l = np.random.uniform(-1,1)  #参数l
            p = np.random.rand()
            if p < pp:
                if abs(A) >= 1:
                    rand_leader = np.random.randint(0, num)
                    X_rand = x[rand_leader, :]
                    D_X_rand = abs(C * X_rand - x[i, :])
                    xx[i, :] = w*X_rand - A * D_X_rand
                    xx[i, :] = type_x(xx[i, :],type,n) #对自变量进行限制
                elif abs(A) < 1:
                    D_Leader = abs(C * best_x - x[i, :])
                    xx[i, :] = w*best_x - A * D_Leader
                    xx[i, :] = type_x(xx[i, :],type,n) #对自变量进行限制
            elif p >= pp:
                D = abs(best_x - x[i, :])
                xx[i, :] = D*np.exp(b*l)*np.cos(2*np.pi*l) + (1-w)*best_x   #完整的气泡网捕食公式
                xx[i, :] = type_x(xx[i, :],type,n) #对自变量进行限制
            ff[i] = fun(xx[i, :])
            if len(np.unique(ff[:i]))/(i+1) <= 0.1:     #limit阈值 + 随机差分变异！！！创新点
                xx[i,:] = (r1*(best_x-xx[i,:]) +
                           r2*(x[np.random.randint(0,num),:] - xx[i,:]))
                xx[i, :] = type_x(xx[i, :],type,n) #对自变量进行限制
                ff[i] = fun(xx[i, :])
        #将上一代种群与这一代种群以及最优种群结合，选取排名靠前的个体组成新的种群
        F = np.hstack((np.array([best_f]), f, ff))
        F, b = np.sort(F,axis=-1,kind='stable'), np.argsort(F)#按小到大排序,获得靠前的位置
        X = np.vstack(([best_x], x, xx))[b, :]
        f = F[:num]  #新种群的位置
        x = X[:num, :]  #新种群的位置
        best_f, a = new_min(f)  # 记录历史最优值
        best_x = x[a , :]  # 记录历史最优解
        trace = np.hstack((trace, [best_f]))
    return best_x,best_f,trace

best_x,best_f,trace = woa(sub,up,type,20,60)     #种群大小，迭代次数
#种群大小可以为自变量个数，迭代次数看情况
print('最优解为：')
print(best_x)
print('最优值为：')
print(float(best_f))

plt.title('鲸鱼算法')
plt.plot(range(1,len(trace)+1),trace, color='r')
plt.show()
数学建模
改进的鲸鱼算法代码
https://jimes.cn/2024/09/11/改进的鲸鱼算法代码/
作者
Jimes
发布于
2024年9月11日
许可协议
\ No newline at end of file +改进的鲸鱼算法代码 - 马锦的博客

改进的鲸鱼算法代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
import numpy as np
from numpy import random
from copy import deepcopy
from tqdm import tqdm
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings("ignore")
np.set_printoptions(threshold=np.inf) # threshold 指定超过多少使用省略号，np.inf代表无限大
np.set_printoptions(suppress=True) #不以科学计数法输出
plt.rcParams['axes.unicode_minus'] = False #显示负号
plt.rcParams['font.family'] = ['sans-serif']
plt.rcParams['font.sans-serif'] = ['SimHei']  # 散点图标签可以显示中文
def fun(X):  # 目标函数和约束条件
    x = X.flatten() #将X变为一维数组
    fx = 0
    for i in range(len(x)-1):
        a = x[i]**2 - 10*np.cos(2*np.pi*x[i]) + 10
        fx += a
    fx += -7*x[-1]
    return fx      #施加惩罚项

s = np.zeros((1,30))
sub = np.array(s-10).ravel()  # 自变量下限
up = np.array(s+10).ravel()  # 自变量上限
type = np.array(s).ravel()    #-1是有理数，0是整数，1是0-1变量

def dd2(best_x, x):  #欧氏距离
    best_x = np.array(best_x)   #转化成numpy数组
    x = np.array(x)          #转化成numpy数组
    c = np.sum(pow(x - best_x, 2), axis=1)    #求方差，在行上的标准差
    d = pow(c, 0.5)   #标准差
    return d
def new_min(arr):  #求最小
    min_data = min(arr)   #找到最小值
    key = np.argmin(arr)  #找到最小值的索引
    return min_data, key
def type_x(xx,type,n):  #变量范围约束
    for v in range(n):
        if type[v] == -1:
            xx[v] = np.maximum(sub[v], xx[v])
            xx[v] = np.minimum(up[v], xx[v])
        elif type[v] == 0:
            xx[v] = np.maximum(sub[v], int(xx[v]))
            xx[v] = np.minimum(up[v], int(xx[v]))
        else:
            xx[v] = np.maximum(sub[v], random.randint(0,2))
            xx[v] = np.minimum(up[v], random.randint(0,2))
    return xx
def woa(sub,up,type,nums,det):
    n = len(sub)  # 自变量个数
    num = nums * n  # 种群大小
    x = np.zeros([num, n])  #生成保存解的矩阵
    f = np.zeros(num)   #生成保存值的矩阵
    for s in range(num):      #随机生成初始解
        for v in range(n):
            rand_data = np.random.uniform(0,1)
            x[s, v] = sub[v] + (up[v] - sub[v]) * rand_data
        x[s, :] = type_x(x[s, :],type,n)
        f[s] = fun(x[s, :])
    best_f, a = new_min(f)  # 记录历史最优值
    best_x = x[a, :]  # 记录历史最优解
    trace = np.array([deepcopy(best_f)]) #记录初始最优值,以便后期添加最优值画图
    ############################ 改进的鲸鱼算法 ################################
    xx = np.zeros([num, n])
    ff = np.zeros(num)
    Mc = (up - sub) * 0.1  # 猎物行动最大范围
    for ii in tqdm(range(det)):      #设置迭代次数，进入迭代过程
        # 猎物躲避,蒙特卡洛模拟，并选择最佳的点作为下一逃跑点 #########！！！创新点
        d = dd2(best_x, x)  #记录当前解与最优解的距离
        d.sort()  #从小到大排序,d[0]恒为0
        z = np.exp(-d[1] / np.mean(Mc))  # 猎物急躁系数
        z = max(z, 0.1)     #决定最终系数
        yx = []  #初始化存储函数值
        dx = []  #初始化存储解
        random_rand = random.random(n) #0-1的随机数
        for i in range(50):    #蒙特卡洛模拟的次数
            m = [random.choice([-1, 1]) for _ in range(n)] #随机的-1和1
            asd = best_x + Mc * z * ((det-ii )/det) * random_rand * m   #最优解更新公式
            xd = type_x(asd,type,n)  #对自变量进行限制
            if i < 1:
                dx = deepcopy(xd)
            else:
                dx = np.vstack((dx,xd))   #存储每一次的解
            yx=np.hstack((yx,fun(xd)))    #存储每一次的值
        best_t, a = new_min(yx)  # 选择最佳逃跑点
        best_c = dx[a, :]   #最佳逃跑点
        if best_t < best_f:   #与鲸鱼算法得到的最优值对比
            best_f = best_t   #更新最优值
            best_x = best_c   #更新最优解
        ############################# 鲸鱼追捕 #################################
        w = (ii / det)**3   #自适应惯性权重!!!创新点
        a = (2 - 2*ii/det)*(1- w)  #a随迭代次数从2非线性下降至0！！！创新点
        pp=0.7 if ii <= 0.5*det else 0.4
        for i in range(num):
            r1 = np.random.rand()  # r1为[0,1]之间的随机数
            r2 = np.random.rand()  # r2为[0,1]之间的随机数
            A = 2 * a * r1 - a
            C = 2 * r2
            b = 1     #螺旋形状系数
            l = np.random.uniform(-1,1)  #参数l
            p = np.random.rand()
            if p < pp:
                if abs(A) >= 1:
                    rand_leader = np.random.randint(0, num)
                    X_rand = x[rand_leader, :]
                    D_X_rand = abs(C * X_rand - x[i, :])
                    xx[i, :] = w*X_rand - A * D_X_rand
                    xx[i, :] = type_x(xx[i, :],type,n) #对自变量进行限制
                elif abs(A) < 1:
                    D_Leader = abs(C * best_x - x[i, :])
                    xx[i, :] = w*best_x - A * D_Leader
                    xx[i, :] = type_x(xx[i, :],type,n) #对自变量进行限制
            elif p >= pp:
                D = abs(best_x - x[i, :])
                xx[i, :] = D*np.exp(b*l)*np.cos(2*np.pi*l) + (1-w)*best_x   #完整的气泡网捕食公式
                xx[i, :] = type_x(xx[i, :],type,n) #对自变量进行限制
            ff[i] = fun(xx[i, :])
            if len(np.unique(ff[:i]))/(i+1) <= 0.1:     #limit阈值 + 随机差分变异！！！创新点
                xx[i,:] = (r1*(best_x-xx[i,:]) +
                           r2*(x[np.random.randint(0,num),:] - xx[i,:]))
                xx[i, :] = type_x(xx[i, :],type,n) #对自变量进行限制
                ff[i] = fun(xx[i, :])
        #将上一代种群与这一代种群以及最优种群结合，选取排名靠前的个体组成新的种群
        F = np.hstack((np.array([best_f]), f, ff))
        F, b = np.sort(F,axis=-1,kind='stable'), np.argsort(F)#按小到大排序,获得靠前的位置
        X = np.vstack(([best_x], x, xx))[b, :]
        f = F[:num]  #新种群的位置
        x = X[:num, :]  #新种群的位置
        best_f, a = new_min(f)  # 记录历史最优值
        best_x = x[a , :]  # 记录历史最优解
        trace = np.hstack((trace, [best_f]))
    return best_x,best_f,trace

best_x,best_f,trace = woa(sub,up,type,20,60)     #种群大小，迭代次数
#种群大小可以为自变量个数，迭代次数看情况
print('最优解为：')
print(best_x)
print('最优值为：')
print(float(best_f))

plt.title('鲸鱼算法')
plt.plot(range(1,len(trace)+1),trace, color='r')
plt.show()
数学建模
改进的鲸鱼算法代码
https://jimes.cn/2024/09/11/改进的鲸鱼算法代码/
作者
Jimes
发布于
2024年9月11日
许可协议
+ + \ No newline at end of file diff --git "a/2024/09/11/\346\250\241\346\213\237\351\200\200\347\201\253\347\256\227\346\263\225\344\273\243\347\240\201/index.html" "b/2024/09/11/\346\250\241\346\213\237\351\200\200\347\201\253\347\256\227\346\263\225\344\273\243\347\240\201/index.html" index 7e35ecf..9b1eb7f 100644 --- "a/2024/09/11/\346\250\241\346\213\237\351\200\200\347\201\253\347\256\227\346\263\225\344\273\243\347\240\201/index.html" +++ "b/2024/09/11/\346\250\241\346\213\237\351\200\200\347\201\253\347\256\227\346\263\225\344\273\243\347\240\201/index.html" @@ -1 +1,14 @@ -模拟退火算法代码 - 马锦的博客

模拟退火算法代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
'''参考文献：
（1）胡山鹰，陈丙珍，非线性规划问题全局优化的模拟退火法，清华大学学报，1997,37(6):5-9
（2）李歧强，具有约束指导的模拟退火算法，系统工程，2001,19(3):49-55
'''
import random
import numpy as np
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings("ignore")
plt.rcParams['axes.unicode_minus'] = False #显示负号
plt.rcParams['font.family'] = ['sans-serif']
plt.rcParams['font.sans-serif'] = ['SimHei']  # 散点图标签可以显示中文

# 定义优化问题的目标函数，最小化问题
def Objective_function(X):  # 目标函数和约束条件    最小化
    X = X.flatten() #将X变为一维数组
    x1 = X[0]
    x2 = X[1]
    x3 = X[2]
    p1 = (max(0, 6 * x1 + 5 * x2 - 60)) ** 2     #表达的含义是函数表达式小于0
    p2 = (max(0, 10 * x1 + 20 * x2 - 150)) ** 2
    #如果是等式约束，可以转化成表达式=0，然后目标函数-10000*表达式
    fx = 100.0 * (x2 - x1) ** 2.0 + (1 - x1) ** 2.0 * x3
    return fx + 10000 * (p1 + p2)     #施加惩罚项
def main_work():       #有理数，整数，0-1变量
    sa = SA(x_min=[[-30,-30],[-1],[]],x_max=[[30,30],[1],[]],t1=1000,t0=1e-4,k=0.98,Markov=500,step=0.1)
    fv = sa.optimize()
    plt.title('模拟退火')
    plt.plot(range(1,len(fv)+1), fv, color='r')
    plt.show()
class SA:
    def __init__(self, x_min,x_max,t1,t0,k,Markov,step):
        # ====== 初始化随机数发生器 ======
        randseed = random.randint(1, 100)
        random.seed(randseed)  # 随机数发生器设置种子，也可以设为指定整数

        self.n = len(np.array(x_min).ravel())  # 自变量数量
        self.x_min = x_min  # 给定搜索空间的下限
        self.x_max = x_max  # 给定搜索空间的上限
        self.t1 = t1  # 初始退火温度
        self.t0 = t0  # 终止退火温度，不能是0，因为只会无限趋近于0
        self.k = k  # 降温参数，T(i)=k*T(i-1)
        self.Markov = Markov  # Markov链长度，内循环运行次数
        self.step = step  # 搜索步长

    def optimize(self):
        # ====== 随机产生优化问题的初始解 ======
        xInitial = np.zeros((self.n))  # 初始化，创建数组
        l1 = len(self.x_min[0])
        l2 = len(self.x_min[0]+self.x_min[1])
        for v in range(self.n):
            if v < l1:
                xInitial[v] = np.random.uniform(self.x_min[0][v], self.x_max[0][v])     #有理数
            elif v >= l1 and v < l2:
                xInitial[v] = np.random.randint(self.x_min[1][v-l1], self.x_max[1][v-l1]+1)   #整数
            else:
                xInitial[v] = np.random.randint(0,2)    #0-1变量
        fxInitial = Objective_function(xInitial)

        ##################################      模拟退火算法初始化      ##############################
        xNew = np.zeros((self.n))  # 初始化，创建数组
        xNow = np.zeros((self.n))  # 初始化，创建数组
        xBest = np.zeros((self.n))  # 初始化，创建数组
        xNow[:] = xInitial[:]  # 初始化当前解，将初始解置为当前解
        xBest[:] = xInitial[:]  # 初始化最优解，将当前解置为最优解
        fxNow = fxInitial  # 将初始解的目标函数置为当前值
        fxBest = fxInitial  # 将当前解的目标函数置为最优值
        #print('初始解:{:.6f},{:.6f},\t初始值:{:.6f}'.format(xInitial[0], xInitial[1], fxInitial))

        recordIter = []  # 初始化，外循环次数
        recordFxNow = []  # 初始化，当前解的目标函数值
        recordFxBest = []  # 初始化，最佳解的目标函数值
        recordPBad = []  # 初始化，劣质解的接受概率
        n_Iter = 0  # 外循环迭代次数
        totalMar = 0  # 总计 Markov 链长度
        totalImprove = 0  # fxBest 改善次数
        nMarkov = self.Markov  # 固定长度 Markov链

        ###################################       开始模拟退火优化     ####################################
        # 外循环
        fv = []
        tNow = self.t1  # 当前温度
        while tNow > self.t0:  # 外循环，直到当前温度达到终止温度时结束
            kBetter = 0  # 获得优质解的次数
            kBadAccept = 0  # 接受劣质解的次数
            kBadRefuse = 0  # 拒绝劣质解的次数

            # 内循环
            for k in range(nMarkov):  # 内循环，循环次数为Markov链长度
                totalMar += 1  # 总 Markov链长度计数器

                # ---产生新解
                # 产生新解：通过在当前解附近随机扰动而产生新解，新解必须在 [min,max] 范围内
                # 方案 1：只对 n元变量中的一个进行扰动，其它 n-1个变量保持不变
                xNew[:] = xNow[:]
                v = random.randint(0, self.n - 1)  # 产生 [0,n-1]之间的随机数
                if v < l1:
                    xNew[v] = xNow[v] + self.step * (self.x_max[0][v] - self.x_min[0][v]) * random.normalvariate(0, 1)
                    # random.normalvariate(0, 1)：产生服从均值为0、标准差为 1 的正态分布随机实数
                    xNew[v] = max(min(xNew[v], self.x_max[0][v]), self.x_min[0][v])  # 保证新解在 [min,max] 范围内
                elif v >= l1 and v < l2:
                    xNew[v] = xNow[v] + int(self.step * (self.x_max[1][v-l1] - self.x_min[1][v-l1]) * random.normalvariate(0, 1))
                    # random.normalvariate(0, 1)：产生服从均值为0、标准差为 1 的正态分布随机实数
                    xNew[v] = max(min(xNew[v], self.x_max[1][v-l1]), self.x_min[1][v-l1])  # 保证新解在 [min,max] 范围内
                else:
                    xNew[v] = np.random.randint(0,2)    #0-1变量
                    xNew[v] = max(min(xNew[v], self.x_max[2][v-l2]), self.x_min[2][v-l2])  # 保证新解在 [min,max] 范围内

                # 计算目标函数和能量差
                fxNew = Objective_function(xNew)
                deltaE = fxNew - fxNow

                # 按 Metropolis 准则接受新解
                if fxNew < fxNow:  # 更优解：如果新解的目标函数好于当前解，则接受新解
                    accept = True
                    kBetter += 1
                else:  # 容忍解：如果新解的目标函数比当前解差，则以一定概率接受新解
                    pAccept = np.exp(-np.float64(deltaE) / np.float64(tNow))        # 计算容忍解的状态迁移概率
                    if pAccept > random.random():
                        accept = True  # 接受劣质解
                        kBadAccept += 1
                    else:
                        accept = False  # 拒绝劣质解
                        kBadRefuse += 1

                # 保存新解
                if accept == True:  # 如果接受新解，则将新解保存为当前解
                    xNow[:] = xNew[:]
                    fxNow = fxNew
                    if fxNew < fxBest:  # 如果新解的目标函数好于最优解，则将新解保存为最优解
                        fxBest = fxNew
                        xBest[:] = xNew[:]
                        totalImprove += 1
                        self.step = self.step * 0.99  # 可变搜索步长，逐步减小搜索范围，提高搜索精度

            # 完成当前温度的搜索，保存数据和输出
            pBadAccept = kBadAccept / (kBadAccept + kBadRefuse)  # 劣质解的接受概率
            recordIter.append(n_Iter)  # 当前外循环次数
            recordFxNow.append(round(fxNow, 4))  # 当前解的目标函数值
            recordFxBest.append(round(fxBest, 4))  # 最佳解的目标函数值
            recordPBad.append(round(pBadAccept, 4))  # 最佳解的目标函数值

            #if n_Iter % 10 == 0:  # 模运算，商的余数
                #print('迭代次数:{},温度:{:.3f},最优值:{:.6f}'.format(n_Iter,tNow,fxBest))

            # 缓慢降温至新的温度，降温曲线：T(k)=k*T(k-1)
            tNow = tNow * self.k
            n_Iter = n_Iter + 1
            fxBest = Objective_function(xBest)
            ###############################    结束模拟退火过程    #######################################
        print('--------------模拟退火-------------')
        print('提升次数:{:d}'.format(totalImprove))
        print("求解结果:")
        for i in range(self.n):
            print('\tx[{}] = {:.9f}'.format(i, xBest[i]))
        print('\tf(x):{:.9f}'.format(Objective_function(xBest)))
        return recordFxBest#,fxBest,n_Iter, xBest,  fxNow, recordIter, recordFxNow,  recordPBad

if __name__ == '__main__':
    main_work()
数学建模
模拟退火算法代码
https://jimes.cn/2024/09/11/模拟退火算法代码/
作者
Jimes
发布于
2024年9月11日
许可协议
\ No newline at end of file +模拟退火算法代码 - 马锦的博客

模拟退火算法代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
'''参考文献：
（1）胡山鹰，陈丙珍，非线性规划问题全局优化的模拟退火法，清华大学学报，1997,37(6):5-9
（2）李歧强，具有约束指导的模拟退火算法，系统工程，2001,19(3):49-55
'''
import random
import numpy as np
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings("ignore")
plt.rcParams['axes.unicode_minus'] = False #显示负号
plt.rcParams['font.family'] = ['sans-serif']
plt.rcParams['font.sans-serif'] = ['SimHei']  # 散点图标签可以显示中文

# 定义优化问题的目标函数，最小化问题
def Objective_function(X):  # 目标函数和约束条件    最小化
    X = X.flatten() #将X变为一维数组
    x1 = X[0]
    x2 = X[1]
    x3 = X[2]
    p1 = (max(0, 6 * x1 + 5 * x2 - 60)) ** 2     #表达的含义是函数表达式小于0
    p2 = (max(0, 10 * x1 + 20 * x2 - 150)) ** 2
    #如果是等式约束，可以转化成表达式=0，然后目标函数-10000*表达式
    fx = 100.0 * (x2 - x1) ** 2.0 + (1 - x1) ** 2.0 * x3
    return fx + 10000 * (p1 + p2)     #施加惩罚项
def main_work():       #有理数，整数，0-1变量
    sa = SA(x_min=[[-30,-30],[-1],[]],x_max=[[30,30],[1],[]],t1=1000,t0=1e-4,k=0.98,Markov=500,step=0.1)
    fv = sa.optimize()
    plt.title('模拟退火')
    plt.plot(range(1,len(fv)+1), fv, color='r')
    plt.show()
class SA:
    def __init__(self, x_min,x_max,t1,t0,k,Markov,step):
        # ====== 初始化随机数发生器 ======
        randseed = random.randint(1, 100)
        random.seed(randseed)  # 随机数发生器设置种子，也可以设为指定整数

        self.n = len(np.array(x_min).ravel())  # 自变量数量
        self.x_min = x_min  # 给定搜索空间的下限
        self.x_max = x_max  # 给定搜索空间的上限
        self.t1 = t1  # 初始退火温度
        self.t0 = t0  # 终止退火温度，不能是0，因为只会无限趋近于0
        self.k = k  # 降温参数，T(i)=k*T(i-1)
        self.Markov = Markov  # Markov链长度，内循环运行次数
        self.step = step  # 搜索步长

    def optimize(self):
        # ====== 随机产生优化问题的初始解 ======
        xInitial = np.zeros((self.n))  # 初始化，创建数组
        l1 = len(self.x_min[0])
        l2 = len(self.x_min[0]+self.x_min[1])
        for v in range(self.n):
            if v < l1:
                xInitial[v] = np.random.uniform(self.x_min[0][v], self.x_max[0][v])     #有理数
            elif v >= l1 and v < l2:
                xInitial[v] = np.random.randint(self.x_min[1][v-l1], self.x_max[1][v-l1]+1)   #整数
            else:
                xInitial[v] = np.random.randint(0,2)    #0-1变量
        fxInitial = Objective_function(xInitial)

        ##################################      模拟退火算法初始化      ##############################
        xNew = np.zeros((self.n))  # 初始化，创建数组
        xNow = np.zeros((self.n))  # 初始化，创建数组
        xBest = np.zeros((self.n))  # 初始化，创建数组
        xNow[:] = xInitial[:]  # 初始化当前解，将初始解置为当前解
        xBest[:] = xInitial[:]  # 初始化最优解，将当前解置为最优解
        fxNow = fxInitial  # 将初始解的目标函数置为当前值
        fxBest = fxInitial  # 将当前解的目标函数置为最优值
        #print('初始解:{:.6f},{:.6f},\t初始值:{:.6f}'.format(xInitial[0], xInitial[1], fxInitial))

        recordIter = []  # 初始化，外循环次数
        recordFxNow = []  # 初始化，当前解的目标函数值
        recordFxBest = []  # 初始化，最佳解的目标函数值
        recordPBad = []  # 初始化，劣质解的接受概率
        n_Iter = 0  # 外循环迭代次数
        totalMar = 0  # 总计 Markov 链长度
        totalImprove = 0  # fxBest 改善次数
        nMarkov = self.Markov  # 固定长度 Markov链

        ###################################       开始模拟退火优化     ####################################
        # 外循环
        fv = []
        tNow = self.t1  # 当前温度
        while tNow > self.t0:  # 外循环，直到当前温度达到终止温度时结束
            kBetter = 0  # 获得优质解的次数
            kBadAccept = 0  # 接受劣质解的次数
            kBadRefuse = 0  # 拒绝劣质解的次数

            # 内循环
            for k in range(nMarkov):  # 内循环，循环次数为Markov链长度
                totalMar += 1  # 总 Markov链长度计数器

                # ---产生新解
                # 产生新解：通过在当前解附近随机扰动而产生新解，新解必须在 [min,max] 范围内
                # 方案 1：只对 n元变量中的一个进行扰动，其它 n-1个变量保持不变
                xNew[:] = xNow[:]
                v = random.randint(0, self.n - 1)  # 产生 [0,n-1]之间的随机数
                if v < l1:
                    xNew[v] = xNow[v] + self.step * (self.x_max[0][v] - self.x_min[0][v]) * random.normalvariate(0, 1)
                    # random.normalvariate(0, 1)：产生服从均值为0、标准差为 1 的正态分布随机实数
                    xNew[v] = max(min(xNew[v], self.x_max[0][v]), self.x_min[0][v])  # 保证新解在 [min,max] 范围内
                elif v >= l1 and v < l2:
                    xNew[v] = xNow[v] + int(self.step * (self.x_max[1][v-l1] - self.x_min[1][v-l1]) * random.normalvariate(0, 1))
                    # random.normalvariate(0, 1)：产生服从均值为0、标准差为 1 的正态分布随机实数
                    xNew[v] = max(min(xNew[v], self.x_max[1][v-l1]), self.x_min[1][v-l1])  # 保证新解在 [min,max] 范围内
                else:
                    xNew[v] = np.random.randint(0,2)    #0-1变量
                    xNew[v] = max(min(xNew[v], self.x_max[2][v-l2]), self.x_min[2][v-l2])  # 保证新解在 [min,max] 范围内

                # 计算目标函数和能量差
                fxNew = Objective_function(xNew)
                deltaE = fxNew - fxNow

                # 按 Metropolis 准则接受新解
                if fxNew < fxNow:  # 更优解：如果新解的目标函数好于当前解，则接受新解
                    accept = True
                    kBetter += 1
                else:  # 容忍解：如果新解的目标函数比当前解差，则以一定概率接受新解
                    pAccept = np.exp(-np.float64(deltaE) / np.float64(tNow))        # 计算容忍解的状态迁移概率
                    if pAccept > random.random():
                        accept = True  # 接受劣质解
                        kBadAccept += 1
                    else:
                        accept = False  # 拒绝劣质解
                        kBadRefuse += 1

                # 保存新解
                if accept == True:  # 如果接受新解，则将新解保存为当前解
                    xNow[:] = xNew[:]
                    fxNow = fxNew
                    if fxNew < fxBest:  # 如果新解的目标函数好于最优解，则将新解保存为最优解
                        fxBest = fxNew
                        xBest[:] = xNew[:]
                        totalImprove += 1
                        self.step = self.step * 0.99  # 可变搜索步长，逐步减小搜索范围，提高搜索精度

            # 完成当前温度的搜索，保存数据和输出
            pBadAccept = kBadAccept / (kBadAccept + kBadRefuse)  # 劣质解的接受概率
            recordIter.append(n_Iter)  # 当前外循环次数
            recordFxNow.append(round(fxNow, 4))  # 当前解的目标函数值
            recordFxBest.append(round(fxBest, 4))  # 最佳解的目标函数值
            recordPBad.append(round(pBadAccept, 4))  # 最佳解的目标函数值

            #if n_Iter % 10 == 0:  # 模运算，商的余数
                #print('迭代次数:{},温度:{:.3f},最优值:{:.6f}'.format(n_Iter,tNow,fxBest))

            # 缓慢降温至新的温度，降温曲线：T(k)=k*T(k-1)
            tNow = tNow * self.k
            n_Iter = n_Iter + 1
            fxBest = Objective_function(xBest)
            ###############################    结束模拟退火过程    #######################################
        print('--------------模拟退火-------------')
        print('提升次数:{:d}'.format(totalImprove))
        print("求解结果:")
        for i in range(self.n):
            print('\tx[{}] = {:.9f}'.format(i, xBest[i]))
        print('\tf(x):{:.9f}'.format(Objective_function(xBest)))
        return recordFxBest#,fxBest,n_Iter, xBest,  fxNow, recordIter, recordFxNow,  recordPBad

if __name__ == '__main__':
    main_work()
数学建模
模拟退火算法代码
https://jimes.cn/2024/09/11/模拟退火算法代码/
作者
Jimes
发布于
2024年9月11日
许可协议
+ + \ No newline at end of file diff --git "a/2024/09/11/\347\201\260\350\211\262\351\242\204\346\265\213/index.html" "b/2024/09/11/\347\201\260\350\211\262\351\242\204\346\265\213/index.html" index ddff2e3..f1ca322 100644 --- "a/2024/09/11/\347\201\260\350\211\262\351\242\204\346\265\213/index.html" +++ "b/2024/09/11/\347\201\260\350\211\262\351\242\204\346\265\213/index.html" @@ -1 +1,14 @@ -灰色预测代码 - 马锦的博客

灰色预测代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
import numpy as np
import math
import matplotlib.pyplot  as plt
from copy import deepcopy
import plotly.graph_objects as go
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
np.set_printoptions(threshold=np.inf) # threshold 指定超过多少使用省略号，np.inf代表无限大
np.set_printoptions(suppress=True) #不以科学计数法输出


X = np.array([-18, 0.34, 4.68, 8.49, 29.84, 50.21, 77.65, 109.36])
x = np.array([[83.0, 79.8, 78.1, 85.1, 86.6, 88.2, 90.3, 86.7, 93.3, 92.5, 90.9, 96.9],
              [101.7, 85.1, 87.8, 91.6, 93.4, 94.5, 97.4, 99.5, 104.2, 102.3, 101.0, 123.5],
              [92.2, 114.0, 93.3, 101.0, 103.5, 105.2, 109.5, 109.2, 109.6, 111.2, 121.7, 131.3],
              [105.0, 125.7, 106.6, 116.0, 117.6, 118.0, 121.7, 118.7, 120.2, 127.8, 121.8, 121.9],
              [139.3, 129.5, 122.5, 124.5, 135.7, 130.8, 138.7, 133.7, 136.8, 138.9, 129.6, 133.7],
              [137.5, 135.3, 133.0, 133.4, 142.8, 141.6, 142.9, 147.3, 159.6, 162.1, 153.5, 155.9]])
def grey_model(X,form,y):      #X为代预测的数列，form为预测的数量,y为是否绘图，0不画，1画
    x_0 = deepcopy(X)
    ##########################################          级比检验         ###########################################
    x_n = [X[i] / X[i + 1] for i in range(len(X) - 1)]       #计算原数列的级比
    if any(n <= math.exp(-2 / (len(X) + 1)) for n in x_n)==True or any(n >= math.exp(-2 / (len(X) + 2)) for n in x_n)==True:
        print('______未通过级比检验______')
        ####################     级比检验不通过处理      ####################
        i = 0
        while True:
            X += 10      #以10为步长慢慢给原数列加数值
            x_n_new = [X[i] / X[i + 1] for i in range(len(X) - 1)]     #计算每一个新的数列的级比
            if any(n <= np.exp(-2 / (len(X) + 1)) for n in x_n_new)==True or any(n >= np.exp(2 / (len(X) + 1)) for n in x_n_new)==True:
                i += 1
                continue
            else:
                print('修正数列为：\n',X)
                sc = 10*(i+1)
                print('修正值为：\n',sc)
                break
    else:
        print("_______通过级比检验______")

    ######################################     模型构建与求解     #######################################
    X_sum = X.cumsum()   # 重新求得累加数列

    z_n = [(X_sum[i] + X_sum[i + 1]) / 2 for i in range(len(X_sum)-1)]   # 紧邻均值序列

    ############# 最小二乘法计算 ###############
    Y = [X[i] for i in range(1,len(X))]  #生成数组Y
    Y = np.array(Y)   #将数组转化为numpy数组
    Y = Y.reshape(-1,1)   #转换格式

    B = [-z_n[i] for i in range(len(z_n))]  #生成数组B
    B = np.array(B)   #将数组转化为numpy数组
    B = B.reshape(-1,1)   #转换格式
    c = np.ones((len(B),1))    #生成数值全为1的一列数组
    B = np.hstack((B,c))     #将两者相连

    parameters = np.linalg.inv(B.T.dot(B)).dot(B.T).dot(Y)  # 通过numpy求出参数（最小二乘法）
    a = parameters[0,0]   #索引到a参数
    b = parameters[1,0]   #索引到b参数
    print("a=",a)   # 打印结果
    print("b=",b)

    #生成预测模型#####################################################        要改在这改     ################################
    b_a = b/a  #提前计算好常数项，减少后续程序的计算
    model_predict = [(X[0] - b_a) * np.exp(-a * k) + b_a for k in range(len(X)+form)]  #生成预测数列

    list_predict = np.concatenate(([model_predict[0]], np.diff(model_predict))) - sc # 先累减获得预测数列，再做差得到真的预测序列

    print("预测数列为:\n",list_predict)
    list_predict = [float(format(i,'.4f')) for i in list_predict]
    if y == 1:
        #####################################     绘图     ####################################
        fig = go.Figure()
        fig.add_trace(go.Scatter(x=list(range(len(X))),y=x_0,         #添加x,y
                                 mode="markers+lines+text",text=x_0,textposition="top center",  #设置坐标点显示
                                 name='原数列'))  #设置标签名
        fig.add_trace(go.Scatter(x=list(range(len(X)+form)),y=list_predict,        #添加x,y
                                 mode="markers+lines+text",text=list_predict,textposition="top center",  #设置坐标点显示
                                 name='预测数列'))   #设置标签名
        fig.update_layout(title="灰色预测",     #设置图表名
                          xaxis=dict(title="时间序号"),    #设置x轴参数
                          yaxis=dict(title="值"),      #设置y轴参数
                          title_x=0.5,  # 将标题居中
                          title_y=0.94,  # 将标题置于上方
                          template="plotly")
        fig.show()

    ########################################      模型检验      #######################################
    G = np.array(list_predict[:len(list_predict)-form])  #生成与真实数列对应的预测数列
    e = x_0 - G  #获得每一个预测值的残差
    q = abs(e / x_0)  # 获得每一个预测值的相对误差
    print("相对误差数列为:\n",q)
    q_q = q.sum()/(len(q)-1)   #求得平均相对误差
    print(f"平均相对误差为:\n{q_q:.4f}")

    S0 = np.sqrt(np.var(x_0))   #原数列的标准差
    S1 = np.sqrt(np.var(e))    #残差数列的标准差
    print('后验差比值C为:\n',S1 / S0)

    E = e.sum()/(len(e)-1)    #计算残差的均值
    yu_zhi = 0.6745*S0
    g = 0
    for i in range(len(e)):
        if abs(e[i]-E) < yu_zhi:
            g += 1
    p = g/len(e)
    print('小概率误差为:\n',p)

    list_p = list_predict[-form:]       #获得我们预测的值
    return list_p

def grey_models(x):
    av = np.array([np.mean(x[i]) for i in range(len(x))])    #求得每一个过程的平均值
    av_predict = grey_model(av,1,0)          #求得预测过程的平均值
    sum_predict = len(x[0]) * av_predict[0]       #计算获得预测过程的总和
    x_x = x.T   #将数组转置

    pre = np.array([grey_model(x_x[i],1,0) for i in range(len(x_x))])       #获得每个过程同一时间在预测过程中的预测值
    pre = pre.ravel()

    c_predict = np.array(pre/sum(pre))     #获得预测过程每一个的预测占比
    c_predict = c_predict.ravel()
    predict = c_predict * sum_predict
    return predict

list_p = grey_model(X,3,1)
print(list_p)
#predict = grey_models(x)
#print(predict)
数学建模
灰色预测代码
https://jimes.cn/2024/09/11/灰色预测/
作者
Jimes
发布于
2024年9月11日
许可协议
\ No newline at end of file +灰色预测代码 - 马锦的博客

灰色预测代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
import numpy as np
import math
import matplotlib.pyplot  as plt
from copy import deepcopy
import plotly.graph_objects as go
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
np.set_printoptions(threshold=np.inf) # threshold 指定超过多少使用省略号，np.inf代表无限大
np.set_printoptions(suppress=True) #不以科学计数法输出


X = np.array([-18, 0.34, 4.68, 8.49, 29.84, 50.21, 77.65, 109.36])
x = np.array([[83.0, 79.8, 78.1, 85.1, 86.6, 88.2, 90.3, 86.7, 93.3, 92.5, 90.9, 96.9],
              [101.7, 85.1, 87.8, 91.6, 93.4, 94.5, 97.4, 99.5, 104.2, 102.3, 101.0, 123.5],
              [92.2, 114.0, 93.3, 101.0, 103.5, 105.2, 109.5, 109.2, 109.6, 111.2, 121.7, 131.3],
              [105.0, 125.7, 106.6, 116.0, 117.6, 118.0, 121.7, 118.7, 120.2, 127.8, 121.8, 121.9],
              [139.3, 129.5, 122.5, 124.5, 135.7, 130.8, 138.7, 133.7, 136.8, 138.9, 129.6, 133.7],
              [137.5, 135.3, 133.0, 133.4, 142.8, 141.6, 142.9, 147.3, 159.6, 162.1, 153.5, 155.9]])
def grey_model(X,form,y):      #X为代预测的数列，form为预测的数量,y为是否绘图，0不画，1画
    x_0 = deepcopy(X)
    ##########################################          级比检验         ###########################################
    x_n = [X[i] / X[i + 1] for i in range(len(X) - 1)]       #计算原数列的级比
    if any(n <= math.exp(-2 / (len(X) + 1)) for n in x_n)==True or any(n >= math.exp(-2 / (len(X) + 2)) for n in x_n)==True:
        print('______未通过级比检验______')
        ####################     级比检验不通过处理      ####################
        i = 0
        while True:
            X += 10      #以10为步长慢慢给原数列加数值
            x_n_new = [X[i] / X[i + 1] for i in range(len(X) - 1)]     #计算每一个新的数列的级比
            if any(n <= np.exp(-2 / (len(X) + 1)) for n in x_n_new)==True or any(n >= np.exp(2 / (len(X) + 1)) for n in x_n_new)==True:
                i += 1
                continue
            else:
                print('修正数列为：\n',X)
                sc = 10*(i+1)
                print('修正值为：\n',sc)
                break
    else:
        print("_______通过级比检验______")

    ######################################     模型构建与求解     #######################################
    X_sum = X.cumsum()   # 重新求得累加数列

    z_n = [(X_sum[i] + X_sum[i + 1]) / 2 for i in range(len(X_sum)-1)]   # 紧邻均值序列

    ############# 最小二乘法计算 ###############
    Y = [X[i] for i in range(1,len(X))]  #生成数组Y
    Y = np.array(Y)   #将数组转化为numpy数组
    Y = Y.reshape(-1,1)   #转换格式

    B = [-z_n[i] for i in range(len(z_n))]  #生成数组B
    B = np.array(B)   #将数组转化为numpy数组
    B = B.reshape(-1,1)   #转换格式
    c = np.ones((len(B),1))    #生成数值全为1的一列数组
    B = np.hstack((B,c))     #将两者相连

    parameters = np.linalg.inv(B.T.dot(B)).dot(B.T).dot(Y)  # 通过numpy求出参数（最小二乘法）
    a = parameters[0,0]   #索引到a参数
    b = parameters[1,0]   #索引到b参数
    print("a=",a)   # 打印结果
    print("b=",b)

    #生成预测模型#####################################################        要改在这改     ################################
    b_a = b/a  #提前计算好常数项，减少后续程序的计算
    model_predict = [(X[0] - b_a) * np.exp(-a * k) + b_a for k in range(len(X)+form)]  #生成预测数列

    list_predict = np.concatenate(([model_predict[0]], np.diff(model_predict))) - sc # 先累减获得预测数列，再做差得到真的预测序列

    print("预测数列为:\n",list_predict)
    list_predict = [float(format(i,'.4f')) for i in list_predict]
    if y == 1:
        #####################################     绘图     ####################################
        fig = go.Figure()
        fig.add_trace(go.Scatter(x=list(range(len(X))),y=x_0,         #添加x,y
                                 mode="markers+lines+text",text=x_0,textposition="top center",  #设置坐标点显示
                                 name='原数列'))  #设置标签名
        fig.add_trace(go.Scatter(x=list(range(len(X)+form)),y=list_predict,        #添加x,y
                                 mode="markers+lines+text",text=list_predict,textposition="top center",  #设置坐标点显示
                                 name='预测数列'))   #设置标签名
        fig.update_layout(title="灰色预测",     #设置图表名
                          xaxis=dict(title="时间序号"),    #设置x轴参数
                          yaxis=dict(title="值"),      #设置y轴参数
                          title_x=0.5,  # 将标题居中
                          title_y=0.94,  # 将标题置于上方
                          template="plotly")
        fig.show()

    ########################################      模型检验      #######################################
    G = np.array(list_predict[:len(list_predict)-form])  #生成与真实数列对应的预测数列
    e = x_0 - G  #获得每一个预测值的残差
    q = abs(e / x_0)  # 获得每一个预测值的相对误差
    print("相对误差数列为:\n",q)
    q_q = q.sum()/(len(q)-1)   #求得平均相对误差
    print(f"平均相对误差为:\n{q_q:.4f}")

    S0 = np.sqrt(np.var(x_0))   #原数列的标准差
    S1 = np.sqrt(np.var(e))    #残差数列的标准差
    print('后验差比值C为:\n',S1 / S0)

    E = e.sum()/(len(e)-1)    #计算残差的均值
    yu_zhi = 0.6745*S0
    g = 0
    for i in range(len(e)):
        if abs(e[i]-E) < yu_zhi:
            g += 1
    p = g/len(e)
    print('小概率误差为:\n',p)

    list_p = list_predict[-form:]       #获得我们预测的值
    return list_p

def grey_models(x):
    av = np.array([np.mean(x[i]) for i in range(len(x))])    #求得每一个过程的平均值
    av_predict = grey_model(av,1,0)          #求得预测过程的平均值
    sum_predict = len(x[0]) * av_predict[0]       #计算获得预测过程的总和
    x_x = x.T   #将数组转置

    pre = np.array([grey_model(x_x[i],1,0) for i in range(len(x_x))])       #获得每个过程同一时间在预测过程中的预测值
    pre = pre.ravel()

    c_predict = np.array(pre/sum(pre))     #获得预测过程每一个的预测占比
    c_predict = c_predict.ravel()
    predict = c_predict * sum_predict
    return predict

list_p = grey_model(X,3,1)
print(list_p)
#predict = grey_models(x)
#print(predict)
数学建模
灰色预测代码
https://jimes.cn/2024/09/11/灰色预测/
作者
Jimes
发布于
2024年9月11日
许可协议
+ + \ No newline at end of file diff --git "a/2024/09/11/\347\262\222\345\255\220\347\276\244\347\256\227\346\263\225\344\273\243\347\240\201/index.html" "b/2024/09/11/\347\262\222\345\255\220\347\276\244\347\256\227\346\263\225\344\273\243\347\240\201/index.html" index 342a8f9..c511313 100644 --- "a/2024/09/11/\347\262\222\345\255\220\347\276\244\347\256\227\346\263\225\344\273\243\347\240\201/index.html" +++ "b/2024/09/11/\347\262\222\345\255\220\347\276\244\347\256\227\346\263\225\344\273\243\347\240\201/index.html" @@ -1 +1,14 @@ -粒子群算法代码 - 马锦的博客

粒子群算法代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
import numpy as np
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings("ignore")
plt.rcParams['axes.unicode_minus'] = False #显示负号
plt.rcParams['font.family'] = ['sans-serif']
plt.rcParams['font.sans-serif'] = ['SimHei']  # 散点图标签可以显示中文

def Objective_function(X):  # 目标函数和约束条件    最小化
    X = X.flatten() #将X变为一维数组
    x1 = X[0]
    x2 = X[1]
    x3 = X[2]
    p1 = (max(0, 6 * x1 + 5 * x2 - 60)) ** 2     #表达的含义是函数表达式小于0
    p2 = (max(0, 10 * x1 + 20 * x2 - 150)) ** 2
    #如果是等式约束，可以转化成表达式=0，然后目标函数-10000*表达式
    fx = 100.0 * (x2 - x1) ** 2.0 + (1 - x1) ** 2.0 * x3
    return fx + 10000 * (p1 + p2)     #施加惩罚项

def main_work():
    # ( 粒子个数, 最大迭代次数,x_min,x_max, max_vel, 阈值, C1=2, C2=2, W=1)   范围都是左闭右开
    pso = PSO(10, 10000,[[-30,-30],[-1],[]],[[30,30],[1],[]], 30, -1000, C1=1, C2=2, W=1)
    fit_var_list, best_pos = pso.update_ndim()
    print("最优位置:" + str(best_pos))
    print(f"最优解为：{fit_var_list[-1]:.9f}")
    plt.title('粒子群')
    plt.plot([i for i in range(1,len(fit_var_list)+1)],fit_var_list, color='r')
    plt.show()

class particle:
    # 初始化
    def __init__(self, x_min, x_max, max_vel, dim):
        pos = np.zeros((dim))
        self.l1 = len(x_min[0])
        self.l2 = len(x_min[0]+x_min[1])
        for v in range(dim):           #生成初始解
            if v < self.l1:
                pos[v] = np.random.uniform(x_min[0][v], x_max[0][v])     #有理数
            elif v >= self.l1 and v < self.l2:
                pos[v] = np.random.randint(x_min[1][v-self.l1], x_max[1][v-self.l1]+1)   #整数
            else:
                pos[v] = np.random.randint(0,2)    #0-1变量
        self.__pos = np.array(pos)  # 粒子的位置
        self.__vel = np.random.uniform(-max_vel, max_vel, (1, dim))  # 粒子的速度
        self.__bestPos = np.zeros((1, dim))  # 粒子最好的位置
        self.__fitnessValue = Objective_function(self.__pos)  # 适应度函数值
#__开头的为私有属性，只在类内存在
    def set_pos(self, value):
        pos = np.array(value).ravel()
        self.__pos = pos
    def get_pos(self):
        return self.__pos
    def set_best_pos(self, value):
        self.__bestPos = value
    def get_best_pos(self):
        return self.__bestPos
    def set_vel(self, value):
        self.__vel = value
    def get_vel(self):
        return self.__vel
    def set_fitness_value(self, value):
        self.__fitnessValue = value
    def get_fitness_value(self):
        return self.__fitnessValue

class PSO:
    def __init__(self,  size, iter_num, x_min,x_max, max_vel, tol, best_fitness_value=float('Inf'), C1=2, C2=2, W=1):
        self.C1 = C1      #加速常数1，控制局部最优解
        self.C2 = C2      #加速常数2，控制全局最优解
        self.W = W        #惯性因子
        self.dim = len(np.array(x_min).ravel())  # 粒子的维度，变量个数
        self.size = size  # 粒子个数
        self.iter_num = iter_num  # 迭代次数
        self.x_min = x_min    #x 的下限
        self.x_max = x_max     # x 的上限
        self.max_vel = max_vel  # 粒子最大速度
        self.tol = tol  # 截止条件
        self.l1 = len(x_min[0])
        self.l2 = len(x_min[0]+x_min[1])
        self.best_fitness_value = best_fitness_value
        self.best_position = np.zeros((1, self.dim))  # 种群最优位置
        self.fitness_val_list = []  # 每次迭代最优适应值
        # 对种群进行初始化
        self.Particle_list = [particle(self.x_min,self.x_max, self.max_vel, self.dim) for i in range(self.size)]
    def set_bestFitnessValue(self, value):
        self.best_fitness_value = value
    def get_bestFitnessValue(self):
        return self.best_fitness_value
    def set_bestPosition(self, value):
        self.best_position = value
    def get_bestPosition(self):
        return self.best_position
    # 更新速度
    def update_vel(self, part):
        vel_value = self.W * part.get_vel() + self.C1 * np.random.rand() * (part.get_best_pos() - part.get_pos()) \
                    + self.C2 * np.random.rand() * (self.get_bestPosition() - part.get_pos())
        vel_value[vel_value > self.max_vel] = self.max_vel
        vel_value[vel_value < -self.max_vel] = -self.max_vel
        part.set_vel(vel_value)
    # 更新位置
    def update_pos(self, part):
        pos_value = part.get_pos() + part.get_vel()
        pos_value = np.array(pos_value).ravel()
        for v in range(len(pos_value)):           #生成初始解
            if v < self.l1:
                pos_value[v] = max(min(pos_value[v], self.x_max[0][v]), self.x_min[0][v])  # 保证新解在 [min,max] 范围内
            elif v >= self.l1 and v < self.l2:
                pos_value[v] = max(min(pos_value[v], self.x_max[1][v-self.l1]), self.x_min[1][v-self.l1])  # 保证新解在 [min,max] 范围内
            else:
                pos_value[v] = max(min(pos_value[v], self.x_max[1][v-self.l2]), self.x_min[1][v-self.l2])  # 保证新解在 [min,max] 范围内
        part.set_pos(pos_value)
        value = Objective_function(part.get_pos())
        if value < part.get_fitness_value():
            part.set_fitness_value(value)
            part.set_best_pos(pos_value)
        if value < self.get_bestFitnessValue():
            self.set_bestFitnessValue(value)
            self.set_bestPosition(pos_value)
    #更新粒子
    def update_ndim(self):
        for i in range(self.iter_num):
            for part in self.Particle_list:
                self.update_vel(part)  # 更新速度
                self.update_pos(part)  # 更新位置
            self.fitness_val_list.append(self.get_bestFitnessValue())  # 每次迭代完把当前的最优适应度存到列表
            print('第{}次最佳适应值为{}'.format(i, self.get_bestFitnessValue()))#################################################
            if self.get_bestFitnessValue() < self.tol:
                break
        print('--------------粒子群--------------')
        return self.fitness_val_list, self.get_bestPosition()
if __name__ == '__main__':
    main_work()
数学建模
粒子群算法代码
https://jimes.cn/2024/09/11/粒子群算法代码/
作者
Jimes
发布于
2024年9月11日
许可协议
\ No newline at end of file +粒子群算法代码 - 马锦的博客

粒子群算法代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
import numpy as np
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings("ignore")
plt.rcParams['axes.unicode_minus'] = False #显示负号
plt.rcParams['font.family'] = ['sans-serif']
plt.rcParams['font.sans-serif'] = ['SimHei']  # 散点图标签可以显示中文

def Objective_function(X):  # 目标函数和约束条件    最小化
    X = X.flatten() #将X变为一维数组
    x1 = X[0]
    x2 = X[1]
    x3 = X[2]
    p1 = (max(0, 6 * x1 + 5 * x2 - 60)) ** 2     #表达的含义是函数表达式小于0
    p2 = (max(0, 10 * x1 + 20 * x2 - 150)) ** 2
    #如果是等式约束，可以转化成表达式=0，然后目标函数-10000*表达式
    fx = 100.0 * (x2 - x1) ** 2.0 + (1 - x1) ** 2.0 * x3
    return fx + 10000 * (p1 + p2)     #施加惩罚项

def main_work():
    # ( 粒子个数, 最大迭代次数,x_min,x_max, max_vel, 阈值, C1=2, C2=2, W=1)   范围都是左闭右开
    pso = PSO(10, 10000,[[-30,-30],[-1],[]],[[30,30],[1],[]], 30, -1000, C1=1, C2=2, W=1)
    fit_var_list, best_pos = pso.update_ndim()
    print("最优位置:" + str(best_pos))
    print(f"最优解为：{fit_var_list[-1]:.9f}")
    plt.title('粒子群')
    plt.plot([i for i in range(1,len(fit_var_list)+1)],fit_var_list, color='r')
    plt.show()

class particle:
    # 初始化
    def __init__(self, x_min, x_max, max_vel, dim):
        pos = np.zeros((dim))
        self.l1 = len(x_min[0])
        self.l2 = len(x_min[0]+x_min[1])
        for v in range(dim):           #生成初始解
            if v < self.l1:
                pos[v] = np.random.uniform(x_min[0][v], x_max[0][v])     #有理数
            elif v >= self.l1 and v < self.l2:
                pos[v] = np.random.randint(x_min[1][v-self.l1], x_max[1][v-self.l1]+1)   #整数
            else:
                pos[v] = np.random.randint(0,2)    #0-1变量
        self.__pos = np.array(pos)  # 粒子的位置
        self.__vel = np.random.uniform(-max_vel, max_vel, (1, dim))  # 粒子的速度
        self.__bestPos = np.zeros((1, dim))  # 粒子最好的位置
        self.__fitnessValue = Objective_function(self.__pos)  # 适应度函数值
#__开头的为私有属性，只在类内存在
    def set_pos(self, value):
        pos = np.array(value).ravel()
        self.__pos = pos
    def get_pos(self):
        return self.__pos
    def set_best_pos(self, value):
        self.__bestPos = value
    def get_best_pos(self):
        return self.__bestPos
    def set_vel(self, value):
        self.__vel = value
    def get_vel(self):
        return self.__vel
    def set_fitness_value(self, value):
        self.__fitnessValue = value
    def get_fitness_value(self):
        return self.__fitnessValue

class PSO:
    def __init__(self,  size, iter_num, x_min,x_max, max_vel, tol, best_fitness_value=float('Inf'), C1=2, C2=2, W=1):
        self.C1 = C1      #加速常数1，控制局部最优解
        self.C2 = C2      #加速常数2，控制全局最优解
        self.W = W        #惯性因子
        self.dim = len(np.array(x_min).ravel())  # 粒子的维度，变量个数
        self.size = size  # 粒子个数
        self.iter_num = iter_num  # 迭代次数
        self.x_min = x_min    #x 的下限
        self.x_max = x_max     # x 的上限
        self.max_vel = max_vel  # 粒子最大速度
        self.tol = tol  # 截止条件
        self.l1 = len(x_min[0])
        self.l2 = len(x_min[0]+x_min[1])
        self.best_fitness_value = best_fitness_value
        self.best_position = np.zeros((1, self.dim))  # 种群最优位置
        self.fitness_val_list = []  # 每次迭代最优适应值
        # 对种群进行初始化
        self.Particle_list = [particle(self.x_min,self.x_max, self.max_vel, self.dim) for i in range(self.size)]
    def set_bestFitnessValue(self, value):
        self.best_fitness_value = value
    def get_bestFitnessValue(self):
        return self.best_fitness_value
    def set_bestPosition(self, value):
        self.best_position = value
    def get_bestPosition(self):
        return self.best_position
    # 更新速度
    def update_vel(self, part):
        vel_value = self.W * part.get_vel() + self.C1 * np.random.rand() * (part.get_best_pos() - part.get_pos()) \
                    + self.C2 * np.random.rand() * (self.get_bestPosition() - part.get_pos())
        vel_value[vel_value > self.max_vel] = self.max_vel
        vel_value[vel_value < -self.max_vel] = -self.max_vel
        part.set_vel(vel_value)
    # 更新位置
    def update_pos(self, part):
        pos_value = part.get_pos() + part.get_vel()
        pos_value = np.array(pos_value).ravel()
        for v in range(len(pos_value)):           #生成初始解
            if v < self.l1:
                pos_value[v] = max(min(pos_value[v], self.x_max[0][v]), self.x_min[0][v])  # 保证新解在 [min,max] 范围内
            elif v >= self.l1 and v < self.l2:
                pos_value[v] = max(min(pos_value[v], self.x_max[1][v-self.l1]), self.x_min[1][v-self.l1])  # 保证新解在 [min,max] 范围内
            else:
                pos_value[v] = max(min(pos_value[v], self.x_max[1][v-self.l2]), self.x_min[1][v-self.l2])  # 保证新解在 [min,max] 范围内
        part.set_pos(pos_value)
        value = Objective_function(part.get_pos())
        if value < part.get_fitness_value():
            part.set_fitness_value(value)
            part.set_best_pos(pos_value)
        if value < self.get_bestFitnessValue():
            self.set_bestFitnessValue(value)
            self.set_bestPosition(pos_value)
    #更新粒子
    def update_ndim(self):
        for i in range(self.iter_num):
            for part in self.Particle_list:
                self.update_vel(part)  # 更新速度
                self.update_pos(part)  # 更新位置
            self.fitness_val_list.append(self.get_bestFitnessValue())  # 每次迭代完把当前的最优适应度存到列表
            print('第{}次最佳适应值为{}'.format(i, self.get_bestFitnessValue()))#################################################
            if self.get_bestFitnessValue() < self.tol:
                break
        print('--------------粒子群--------------')
        return self.fitness_val_list, self.get_bestPosition()
if __name__ == '__main__':
    main_work()
数学建模
粒子群算法代码
https://jimes.cn/2024/09/11/粒子群算法代码/
作者
Jimes
发布于
2024年9月11日
许可协议
+ + \ No newline at end of file diff --git "a/2024/09/11/\347\273\223\345\220\210\347\206\265\346\235\203\346\263\225\347\232\204topsis\345\256\242\350\247\202\350\257\204\344\273\267/index.html" "b/2024/09/11/\347\273\223\345\220\210\347\206\265\346\235\203\346\263\225\347\232\204topsis\345\256\242\350\247\202\350\257\204\344\273\267/index.html" index a16011f..d489eff 100644 --- "a/2024/09/11/\347\273\223\345\220\210\347\206\265\346\235\203\346\263\225\347\232\204topsis\345\256\242\350\247\202\350\257\204\344\273\267/index.html" +++ "b/2024/09/11/\347\273\223\345\220\210\347\206\265\346\235\203\346\263\225\347\232\204topsis\345\256\242\350\247\202\350\257\204\344\273\267/index.html" @@ -1 +1,14 @@ -结合熵权法的topsis客观评价代码 - 马锦的博客

结合熵权法的topsis客观评价代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
import numpy as np
import pandas as pd
np.set_printoptions(threshold=np.inf) # threshold 指定超过多少使用省略号，np.inf代表无限大
np.set_printoptions(suppress=True) #不以科学计数法输出

#导入数据
data = pd.read_excel('收发货表格.xlsx',usecols=['发货','收货','总运输','发斜','收斜','平均相关性','发货城市','收货城市','连接数'])
x_data = np.array(data)

#正向化
def positive(x, type, best_value=None, a=None, b=None):
    '''
    :param x: 原始数据
    :param type: 1表示极小型，2表示中间型，3表示区间型,4表示正数话，[[,1],[,2],[,3]]前面是需要正向化的列的序号
    :param best_value: 中间型的最优值
    :param a: 区间型的区间下限
    :param b: 区间型的区间上限
    :return: 正向化后的数据（列）
    '''
    if type == None:     #先判断是否需要正向化
        pass
    else:
        x = x.T  #转置
        m = np.array(type).shape[0]  #获得需要正向化的列数
        for i in range(int(m)):  #迭代需要正向化的列
            if type[i][1] == 1:   #成本型数据的转化，采用max-x
                x[type[i][0]] = x[type[i][0]].max(0)-x[type[i][0]]
            elif type[i][1] == 2:  #中间型数据的转化
                max_value = (abs(x[type[i][0]] - best_value)).max()
                x[type[i][0]] = 1 - abs(x[type[i][0]] - best_value) / max_value
            elif type[i][1] == 3:  #区间型数据的转化
                max_value = (np.append(a-x[type[i][0]].min(),x[type[i][0]].max()-b)).max()  #即M，后面转换时的分母
                x_rows = x[type[i][0]].shape[0]
                for v in range(x_rows):
                    if x[type[i][0]][v] > b:  #当数据大于区间最大值的转换
                        x[type[i][0]][v] = 1-(x[type[i][0]][v]-b)/max_value
                    elif x[type[i][0]][v] < a:   #当数据小于区间最小值的转换
                        x[type[i][0]][v] = 1-(a-x[type[i][0]][v])/max_value
                    elif a <= x[type[i][0]][v] <= b:  #当数据在区间内则给予最优值1
                        x[type[i][0]][v] = 1
                    else:                      #其它情况则给予最劣值0
                        x[type[i][0]][v] = 0
            elif type[i][1] == 4:   #极大型负数的转换
                x[type[i][0]] = 1-(x[type[i][0]].min(0)) + x[type[i][0]]
        return x.T

#标准化
def normalize(x):
    sqrt_sum = (x * x).sum(axis=0)  #每一列元素的平方和
    sqt_sum_z = np.tile(sqrt_sum, (x.shape[0], 1)) #转换格式,每一列的值均为当列的元素平方和
    Z = x / np.sqrt(sqt_sum_z) #标准化
    return Z

#熵权法计算权值
def importance(data):
    l = len(data[0])
    h = [0]*l
    w = [0]*l
    data = data.T
    for v in range(l):
        for i in range(len(data[0])):
            if data[v][i] == 0:
                pass
            else:
                h[v] += -data[v][i] * np.log(data[v][i])/np.log(len(data[0]))       #计算每个指标的信息熵值
    for i in range(l):
        w[i] = (1-h[i])/(len(data)-sum(h))           #计算每个指标的权重
    return w
#topsis算法
def topsis(z,h):
    z_max = z.max(0)  #每一列的最大值与最小值
    z_min = z.min(0)

    d_m = z - np.tile(z_max, (z.shape[0], 1))  #每个方案与最优解及最劣解的差值数列
    d_i = z - np.tile(z_min, (z.shape[0], 1))

    d_i_max = np.sqrt(((h * d_m) ** 2).sum(axis=1))  #每个方案的综合距离
    d_i_min = np.sqrt(((h * d_i) ** 2).sum(axis=1))

    score = d_i_min/(d_i_max + d_i_min) #每个方案的评分
    std_score = score / score.sum(axis=0)  #归一化，方便查看
    return std_score

if __name__ == "__main__":
    #正向化，如果不需要则为空列表即可,要求都为正向化且数据都大于0
    type = [[3,4],[4,4],[1,4],[7,4]]
    a = positive(x_data,type,best_value=None, a=None, b=None)
    #标准化
    b = normalize(a)
    #信息熵计算
    h = importance(b)
    #topsis评价
    s = topsis(b,h)
    #将评价与方案连接，方便对比与观察
    clo = np.array(['A','B','C','D','E','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y'])
    lianjie_list = []
    for i in range(len(s)):
        lianjie_list.append([clo[i], s[i]])
    jieguo = sorted(lianjie_list,reverse=True, key=lambda x: x[1])  #根据评分值进行排序
    print(jieguo)

数学建模
结合熵权法的topsis客观评价代码
https://jimes.cn/2024/09/11/结合熵权法的topsis客观评价/
作者
Jimes
发布于
2024年9月11日
许可协议
\ No newline at end of file +结合熵权法的topsis客观评价代码 - 马锦的博客

结合熵权法的topsis客观评价代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
import numpy as np
import pandas as pd
np.set_printoptions(threshold=np.inf) # threshold 指定超过多少使用省略号，np.inf代表无限大
np.set_printoptions(suppress=True) #不以科学计数法输出

#导入数据
data = pd.read_excel('收发货表格.xlsx',usecols=['发货','收货','总运输','发斜','收斜','平均相关性','发货城市','收货城市','连接数'])
x_data = np.array(data)

#正向化
def positive(x, type, best_value=None, a=None, b=None):
    '''
    :param x: 原始数据
    :param type: 1表示极小型，2表示中间型，3表示区间型,4表示正数话，[[,1],[,2],[,3]]前面是需要正向化的列的序号
    :param best_value: 中间型的最优值
    :param a: 区间型的区间下限
    :param b: 区间型的区间上限
    :return: 正向化后的数据（列）
    '''
    if type == None:     #先判断是否需要正向化
        pass
    else:
        x = x.T  #转置
        m = np.array(type).shape[0]  #获得需要正向化的列数
        for i in range(int(m)):  #迭代需要正向化的列
            if type[i][1] == 1:   #成本型数据的转化，采用max-x
                x[type[i][0]] = x[type[i][0]].max(0)-x[type[i][0]]
            elif type[i][1] == 2:  #中间型数据的转化
                max_value = (abs(x[type[i][0]] - best_value)).max()
                x[type[i][0]] = 1 - abs(x[type[i][0]] - best_value) / max_value
            elif type[i][1] == 3:  #区间型数据的转化
                max_value = (np.append(a-x[type[i][0]].min(),x[type[i][0]].max()-b)).max()  #即M，后面转换时的分母
                x_rows = x[type[i][0]].shape[0]
                for v in range(x_rows):
                    if x[type[i][0]][v] > b:  #当数据大于区间最大值的转换
                        x[type[i][0]][v] = 1-(x[type[i][0]][v]-b)/max_value
                    elif x[type[i][0]][v] < a:   #当数据小于区间最小值的转换
                        x[type[i][0]][v] = 1-(a-x[type[i][0]][v])/max_value
                    elif a <= x[type[i][0]][v] <= b:  #当数据在区间内则给予最优值1
                        x[type[i][0]][v] = 1
                    else:                      #其它情况则给予最劣值0
                        x[type[i][0]][v] = 0
            elif type[i][1] == 4:   #极大型负数的转换
                x[type[i][0]] = 1-(x[type[i][0]].min(0)) + x[type[i][0]]
        return x.T

#标准化
def normalize(x):
    sqrt_sum = (x * x).sum(axis=0)  #每一列元素的平方和
    sqt_sum_z = np.tile(sqrt_sum, (x.shape[0], 1)) #转换格式,每一列的值均为当列的元素平方和
    Z = x / np.sqrt(sqt_sum_z) #标准化
    return Z

#熵权法计算权值
def importance(data):
    l = len(data[0])
    h = [0]*l
    w = [0]*l
    data = data.T
    for v in range(l):
        for i in range(len(data[0])):
            if data[v][i] == 0:
                pass
            else:
                h[v] += -data[v][i] * np.log(data[v][i])/np.log(len(data[0]))       #计算每个指标的信息熵值
    for i in range(l):
        w[i] = (1-h[i])/(len(data)-sum(h))           #计算每个指标的权重
    return w
#topsis算法
def topsis(z,h):
    z_max = z.max(0)  #每一列的最大值与最小值
    z_min = z.min(0)

    d_m = z - np.tile(z_max, (z.shape[0], 1))  #每个方案与最优解及最劣解的差值数列
    d_i = z - np.tile(z_min, (z.shape[0], 1))

    d_i_max = np.sqrt(((h * d_m) ** 2).sum(axis=1))  #每个方案的综合距离
    d_i_min = np.sqrt(((h * d_i) ** 2).sum(axis=1))

    score = d_i_min/(d_i_max + d_i_min) #每个方案的评分
    std_score = score / score.sum(axis=0)  #归一化，方便查看
    return std_score

if __name__ == "__main__":
    #正向化，如果不需要则为空列表即可,要求都为正向化且数据都大于0
    type = [[3,4],[4,4],[1,4],[7,4]]
    a = positive(x_data,type,best_value=None, a=None, b=None)
    #标准化
    b = normalize(a)
    #信息熵计算
    h = importance(b)
    #topsis评价
    s = topsis(b,h)
    #将评价与方案连接，方便对比与观察
    clo = np.array(['A','B','C','D','E','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y'])
    lianjie_list = []
    for i in range(len(s)):
        lianjie_list.append([clo[i], s[i]])
    jieguo = sorted(lianjie_list,reverse=True, key=lambda x: x[1])  #根据评分值进行排序
    print(jieguo)

数学建模
结合熵权法的topsis客观评价代码
https://jimes.cn/2024/09/11/结合熵权法的topsis客观评价/
作者
Jimes
发布于
2024年9月11日
许可协议
+ + \ No newline at end of file diff --git a/2024/10/01/PDF_math/index.html b/2024/10/01/PDF_math/index.html index 3864758..3d04ab1 100644 --- a/2024/10/01/PDF_math/index.html +++ b/2024/10/01/PDF_math/index.html @@ -1 +1,14 @@ -23年数学建模国赛B题 - 马锦的博客

23年数学建模国赛B题

手机端无法查看，可尝试浏览器爬虫功能，建议电脑端查看。

数学建模
23年数学建模国赛B题
https://jimes.cn/2024/10/01/PDF_math/
作者
Jimes
发布于
2024年10月1日
许可协议
\ No newline at end of file +23年数学建模国赛B题 - 马锦的博客

23年数学建模国赛B题

手机端无法查看，可尝试浏览器爬虫功能，建议电脑端查看。

数学建模
23年数学建模国赛B题
https://jimes.cn/2024/10/01/PDF_math/
作者
Jimes
发布于
2024年10月1日
许可协议
+ + \ No newline at end of file diff --git a/404.html b/404.html index b8da928..3124518 100644 --- a/404.html +++ b/404.html @@ -1 +1,14 @@ -页面不存在 - 马锦的博客
\ No newline at end of file +页面不存在 - 马锦的博客
+ + \ No newline at end of file diff --git a/about/index.html b/about/index.html index 3bc81c2..151c75c 100644 --- a/about/index.html +++ b/about/index.html @@ -1 +1,14 @@ -关于 - 马锦的博客
\ No newline at end of file +关于 - 马锦的博客
+ + \ No newline at end of file diff --git a/archives/2024/01/index.html b/archives/2024/01/index.html index f771ac6..6b4dc15 100644 --- a/archives/2024/01/index.html +++ b/archives/2024/01/index.html @@ -1 +1,14 @@ -归档 - 马锦的博客
\ No newline at end of file +归档 - 马锦的博客
+ + \ No newline at end of file diff --git a/archives/2024/02/index.html b/archives/2024/02/index.html index 59c829a..96dafdf 100644 --- a/archives/2024/02/index.html +++ b/archives/2024/02/index.html @@ -1 +1,14 @@ -归档 - 马锦的博客
\ No newline at end of file +归档 - 马锦的博客
+ + \ No newline at end of file diff --git a/archives/2024/07/index.html b/archives/2024/07/index.html index 121856e..76a0447 100644 --- a/archives/2024/07/index.html +++ b/archives/2024/07/index.html @@ -1 +1,14 @@ -归档 - 马锦的博客
\ No newline at end of file +归档 - 马锦的博客
+ + \ No newline at end of file diff --git a/archives/2024/09/index.html b/archives/2024/09/index.html index ae733e7..488a3d3 100644 --- a/archives/2024/09/index.html +++ b/archives/2024/09/index.html @@ -1 +1,14 @@ -归档 - 马锦的博客
\ No newline at end of file +归档 - 马锦的博客
+ + \ No newline at end of file diff --git a/archives/2024/09/page/2/index.html b/archives/2024/09/page/2/index.html deleted file mode 100644 index 25af545..0000000 --- a/archives/2024/09/page/2/index.html +++ /dev/null @@ -1 +0,0 @@ -归档 - 马锦的博客
\ No newline at end of file diff --git a/archives/2024/10/index.html b/archives/2024/10/index.html index 2fc0c2e..3a629c1 100644 --- a/archives/2024/10/index.html +++ b/archives/2024/10/index.html @@ -1 +1,14 @@ -归档 - 马锦的博客

共计 19 篇文章

2024

23年数学建模国赛B题
\ No newline at end of file +归档 - 马锦的博客

共计 19 篇文章

2024

23年数学建模国赛B题
+ + \ No newline at end of file diff --git a/archives/2024/index.html b/archives/2024/index.html index 9386946..8b64927 100644 --- a/archives/2024/index.html +++ b/archives/2024/index.html @@ -1 +1,14 @@ -归档 - 马锦的博客
\ No newline at end of file +归档 - 马锦的博客
+ + \ No newline at end of file diff --git a/archives/2024/page/2/index.html b/archives/2024/page/2/index.html deleted file mode 100644 index bceb1a3..0000000 --- a/archives/2024/page/2/index.html +++ /dev/null @@ -1 +0,0 @@ -归档 - 马锦的博客
\ No newline at end of file diff --git a/archives/index.html b/archives/index.html index ff16c41..600a3e8 100644 --- a/archives/index.html +++ b/archives/index.html @@ -1 +1,14 @@ -归档 - 马锦的博客
\ No newline at end of file +归档 - 马锦的博客
+ + \ No newline at end of file diff --git a/archives/page/2/index.html b/archives/page/2/index.html deleted file mode 100644 index 5e61756..0000000 --- a/archives/page/2/index.html +++ /dev/null @@ -1 +0,0 @@ -归档 - 马锦的博客
\ No newline at end of file diff --git a/categories/index.html b/categories/index.html index fa8b638..76605e9 100644 --- a/categories/index.html +++ b/categories/index.html @@ -1 +1,14 @@ -分类 - 马锦的博客
\ No newline at end of file +分类 - 马锦的博客
+ + \ No newline at end of file diff --git "a/categories/\344\272\272\345\267\245\346\231\272\350\203\275/index.html" "b/categories/\344\272\272\345\267\245\346\231\272\350\203\275/index.html" index b64dffe..ef9aacf 100644 --- "a/categories/\344\272\272\345\267\245\346\231\272\350\203\275/index.html" +++ "b/categories/\344\272\272\345\267\245\346\231\272\350\203\275/index.html" @@ -1 +1,14 @@ -分类 - 人工智能 - 马锦的博客

共计 1 篇文章

2024

人工智能学习导航
\ No newline at end of file +分类 - 人工智能 - 马锦的博客

共计 1 篇文章

2024

人工智能学习导航
+ + \ No newline at end of file diff --git "a/categories/\345\237\272\347\241\200\345\267\245\345\205\267/index.html" "b/categories/\345\237\272\347\241\200\345\267\245\345\205\267/index.html" index 2ff5973..c27b008 100644 --- "a/categories/\345\237\272\347\241\200\345\267\245\345\205\267/index.html" +++ "b/categories/\345\237\272\347\241\200\345\267\245\345\205\267/index.html" @@ -1 +1,14 @@ -分类 - 基础工具 - 马锦的博客
\ No newline at end of file +分类 - 基础工具 - 马锦的博客
+ + \ No newline at end of file diff --git "a/categories/\346\225\260\345\255\246\345\273\272\346\250\241/index.html" "b/categories/\346\225\260\345\255\246\345\273\272\346\250\241/index.html" index bc71366..a35e352 100644 --- "a/categories/\346\225\260\345\255\246\345\273\272\346\250\241/index.html" +++ "b/categories/\346\225\260\345\255\246\345\273\272\346\250\241/index.html" @@ -1 +1,14 @@ -分类 - 数学建模 - 马锦的博客
\ No newline at end of file +分类 - 数学建模 - 马锦的博客
+ + \ No newline at end of file diff --git "a/categories/\346\225\260\345\255\246\345\273\272\346\250\241/page/2/index.html" "b/categories/\346\225\260\345\255\246\345\273\272\346\250\241/page/2/index.html" deleted file mode 100644 index bf53fb2..0000000 --- "a/categories/\346\225\260\345\255\246\345\273\272\346\250\241/page/2/index.html" +++ /dev/null @@ -1 +0,0 @@ -分类 - 数学建模 - 马锦的博客
\ No newline at end of file diff --git "a/categories/\346\270\270\346\210\217/index.html" "b/categories/\346\270\270\346\210\217/index.html" index 7a19d50..e3ac8b5 100644 --- "a/categories/\346\270\270\346\210\217/index.html" +++ "b/categories/\346\270\270\346\210\217/index.html" @@ -1 +1,14 @@ -分类 - 游戏 - 马锦的博客
\ No newline at end of file +分类 - 游戏 - 马锦的博客
+ + \ No newline at end of file diff --git "a/categories/\346\270\270\346\210\217/\350\207\252\345\212\250\345\214\226/index.html" "b/categories/\346\270\270\346\210\217/\350\207\252\345\212\250\345\214\226/index.html" index 0dfde33..b875804 100644 --- "a/categories/\346\270\270\346\210\217/\350\207\252\345\212\250\345\214\226/index.html" +++ "b/categories/\346\270\270\346\210\217/\350\207\252\345\212\250\345\214\226/index.html" @@ -1 +1,14 @@ -分类 - 自动化 - 马锦的博客
\ No newline at end of file +分类 - 自动化 - 马锦的博客
+ + \ No newline at end of file diff --git "a/categories/\350\200\203\347\240\224408/index.html" "b/categories/\350\200\203\347\240\224408/index.html" index 2914960..54a51ac 100644 --- "a/categories/\350\200\203\347\240\224408/index.html" +++ "b/categories/\350\200\203\347\240\224408/index.html" @@ -1 +1,14 @@ -分类 - 考研408 - 马锦的博客
\ No newline at end of file +分类 - 考研408 - 马锦的博客
+ + \ No newline at end of file diff --git a/index.html b/index.html index a782a8b..0929354 100644 --- a/index.html +++ b/index.html @@ -1 +1,14 @@ -马锦的博客
\ No newline at end of file +马锦的博客

人工智能学习导航

1，机器学习算法python实现GitHub项目，讲解了机器学习算法的数学原理与python实现，做笔记必备。 2，Hello算法数据结构类的算法的多方式实现，有c，python，c++等等，同时配备了可视化界面，形象讲解算法的原理与区别。 3，可视化数据结构与算法一个单纯模拟数据结构算法的网站。 4，菜鸟教程学计算机必备，各种语言与第三方库的讲解以及框架，数不胜数！ 5，神经网络与深度学习邱锡鹏
人工智能
+ + \ No newline at end of file diff --git a/links/index.html b/links/index.html index c17acc1..81c8b45 100644 --- a/links/index.html +++ b/links/index.html @@ -1 +1,14 @@ -友链 - 马锦的博客
\ No newline at end of file +友链 - 马锦的博客
+ + \ No newline at end of file diff --git a/page/2/index.html b/page/2/index.html deleted file mode 100644 index 38a34cb..0000000 --- a/page/2/index.html +++ /dev/null @@ -1 +0,0 @@ -马锦的博客

人工智能学习导航

1，机器学习算法python实现GitHub项目，讲解了机器学习算法的数学原理与python实现，做笔记必备。 2，Hello算法数据结构类的算法的多方式实现，有c，python，c++等等，同时配备了可视化界面，形象讲解算法的原理与区别。 3，可视化数据结构与算法一个单纯模拟数据结构算法的网站。 4，菜鸟教程学计算机必备，各种语言与第三方库的讲解以及框架，数不胜数！ 5，神经网络与深度学习邱锡鹏
人工智能
\ No newline at end of file diff --git a/sitemap.xml b/sitemap.xml index 17bfce6..e3d04f8 100644 --- a/sitemap.xml +++ b/sitemap.xml @@ -184,7 +184,7 @@ https://jimes.cn/ - 2024-09-13 + 2024-09-15 daily 1.0 @@ -192,14 +192,14 @@ https://jimes.cn/tags/blog/ - 2024-09-13 + 2024-09-15 weekly 0.2 https://jimes.cn/tags/hexo/ - 2024-09-13 + 2024-09-15 weekly 0.2 @@ -208,70 +208,70 @@ https://jimes.cn/categories/%E5%9F%BA%E7%A1%80%E5%B7%A5%E5%85%B7/ - 2024-09-13 + 2024-09-15 weekly 0.2 https://jimes.cn/categories/%E8%80%83%E7%A0%94408/ - 2024-09-13 + 2024-09-15 weekly 0.2 https://jimes.cn/categories/%E4%BA%BA%E5%B7%A5%E6%99%BA%E8%83%BD/ - 2024-09-13 + 2024-09-15 weekly 0.2 https://jimes.cn/categories/%E6%B8%B8%E6%88%8F-%E8%87%AA%E5%8A%A8%E5%8C%96/ - 2024-09-13 + 2024-09-15 weekly 0.2 https://jimes.cn/categories/%E6%B8%B8%E6%88%8F-%E8%87%AA%E5%8A%A8%E5%8C%96/ - 2024-09-13 + 2024-09-15 weekly 0.2 https://jimes.cn/categories/%E6%B8%B8%E6%88%8F/ - 2024-09-13 + 2024-09-15 weekly 0.2 https://jimes.cn/categories/%E6%B8%B8%E6%88%8F/%E8%87%AA%E5%8A%A8%E5%8C%96/ - 2024-09-13 + 2024-09-15 weekly 0.2 https://jimes.cn/categories/WEB%E5%BC%80%E5%8F%91/ - 2024-09-13 + 2024-09-15 weekly 0.2 https://jimes.cn/categories/WEB%E5%BC%80%E5%8F%91/%E7%AC%AC%E4%BA%8C%E7%B1%BB/ - 2024-09-13 + 2024-09-15 weekly 0.2 https://jimes.cn/categories/%E6%95%B0%E5%AD%A6%E5%BB%BA%E6%A8%A1/ - 2024-09-13 + 2024-09-15 weekly 0.2 diff --git a/sw-register.js b/sw-register.js index bd574a0..9067302 100644 --- a/sw-register.js +++ b/sw-register.js @@ -1 +1 @@ -navigator.serviceWorker&&navigator.serviceWorker.register('/sw.js?v=20240913121710').then(function(){navigator.serviceWorker.addEventListener('message',function(a){if('sw.update'===a.data){let a=document.querySelector('meta[name=theme-color]'),b=document.createElement('div');a&&(a.content='#000'),b.innerHTML='

\u64cd\u4f5c\u901a\u77e5

\u5df2\u66f4\u65b0\u6700\u65b0\u7248\u672c\uff08\u5237\u65b0\u751f\u6548\uff09
×
',document.body.appendChild(b),setTimeout(function(){document.getElementById('app-refresh').className+=' app-refresh-show'},16)}})}); \ No newline at end of file +navigator.serviceWorker&&navigator.serviceWorker.register('/sw.js?v=20240915215629').then(function(){navigator.serviceWorker.addEventListener('message',function(a){if('sw.update'===a.data){let a=document.querySelector('meta[name=theme-color]'),b=document.createElement('div');a&&(a.content='#000'),b.innerHTML='

\u64cd\u4f5c\u901a\u77e5

\u5df2\u66f4\u65b0\u6700\u65b0\u7248\u672c\uff08\u5237\u65b0\u751f\u6548\uff09
×
',document.body.appendChild(b),setTimeout(function(){document.getElementById('app-refresh').className+=' app-refresh-show'},16)}})}); \ No newline at end of file diff --git a/sw.js b/sw.js index 15def5b..1208f7c 100644 --- a/sw.js +++ b/sw.js @@ -10,7 +10,7 @@ 'use strict'; -var precacheConfig = [["/2024/01/09/GitHub desktop基本用法/2023-05-07_232823.png","c24df821a6497444e71b2243e0577a9a"],["/2024/01/09/GitHub desktop基本用法/Untitled 1.png","2fa248a8f262c8636a07d3bd06dcc1fe"],["/2024/01/09/GitHub desktop基本用法/Untitled 10.png","c2154d964d2e468589b86bef5f35d53a"],["/2024/01/09/GitHub desktop基本用法/Untitled 11.png","abda8e93832cdb4fb8b0e6341c8d031f"],["/2024/01/09/GitHub desktop基本用法/Untitled 12.png","3505440efe0f7c43537137fd83adeb14"],["/2024/01/09/GitHub desktop基本用法/Untitled 13.png","46f19d6ccf828fd50d1317069a3aa2bb"],["/2024/01/09/GitHub desktop基本用法/Untitled 14.png","c7d61ce5820b53b7cfb746674160f9c5"],["/2024/01/09/GitHub desktop基本用法/Untitled 15.png","1c74bd4c3c479c6cbb717b5ab7ba9380"],["/2024/01/09/GitHub desktop基本用法/Untitled 16.png","17d74c538216b387e59724648a311cf9"],["/2024/01/09/GitHub desktop基本用法/Untitled 17.png","e61d189ea48bf0684d3c6330cae5b66e"],["/2024/01/09/GitHub desktop基本用法/Untitled 18.png","a0f26d2c02b09e6f98a49b4ed5e92990"],["/2024/01/09/GitHub desktop基本用法/Untitled 19.png","655dace5a204d04f04bb771c1f78f202"],["/2024/01/09/GitHub desktop基本用法/Untitled 2.png","326f9c7a13fe45ec249f127fc0380ccd"],["/2024/01/09/GitHub desktop基本用法/Untitled 20.png","68f746a0060ea6c081d1bf2c1496fb2f"],["/2024/01/09/GitHub desktop基本用法/Untitled 21.png","b1e5ea352441a541703f9d2867bc3841"],["/2024/01/09/GitHub desktop基本用法/Untitled 22.png","9197489c29212235b23d03aaafc12169"],["/2024/01/09/GitHub desktop基本用法/Untitled 23.png","f13175ce125954d6db5235205f48d978"],["/2024/01/09/GitHub desktop基本用法/Untitled 24.png","43e23660e25d8aa2e044c40c459cd400"],["/2024/01/09/GitHub desktop基本用法/Untitled 25.png","138b3364053bb65add68db6669f5d636"],["/2024/01/09/GitHub desktop基本用法/Untitled 26.png","426824e5d019a894a527b700abe629de"],["/2024/01/09/GitHub desktop基本用法/Untitled 27.png","6fcb131534b72e9365601b15cffa56bb"],["/2024/01/09/GitHub desktop基本用法/Untitled 3.png","354fa66f304720bdef613d8096574e32"],["/2024/01/09/GitHub desktop基本用法/Untitled 4.png","cd69f961522f00c1fac975902d60823d"],["/2024/01/09/GitHub desktop基本用法/Untitled 5.png","56c7f45017b1c73b44fe11be74a3b923"],["/2024/01/09/GitHub desktop基本用法/Untitled 6.png","4830b6f9dec4491262ec4335c953bb16"],["/2024/01/09/GitHub desktop基本用法/Untitled 7.png","50613175b6820d882c6b95df34780461"],["/2024/01/09/GitHub desktop基本用法/Untitled 8.png","d8513c20ac045674ba216bca64a1060a"],["/2024/01/09/GitHub desktop基本用法/Untitled 9.png","4305232b7f50b2c39bebbdcf89f10117"],["/2024/01/09/GitHub desktop基本用法/Untitled.png","af1264ba3284f0a578c35ca704f2ab4f"],["/2024/01/09/GitHub desktop基本用法/index.html","c6862d55cf4cc5e0cbd12ce01097a36d"],["/2024/01/10/人工智能学习导航/index.html","298b976ab331ef38952b011396e40afe"],["/2024/01/12/python程序带图片等资源打包/index.html","3ea0547664bdfba569e2a7f2c27c61f1"],["/2024/02/02/数据结构之线性表代码/index.html","8934895b03624ddcbc9c79c116f19540"],["/2024/02/03/数据结构之栈与队列代码/index.html","3b911c5ed4c38952c475a9aa789f2fd5"],["/2024/07/21/生死狙击2净化行动挂机脚本/index.html","6f80be9eca2347f845202b021498be3b"],["/2024/09/11/ARIMA预测/index.html","d742700c70eb77899c83839d40bfbe96"],["/2024/09/11/ARMA预测/index.html","8e30860935a3bd3e4b4aab1f960b7ed7"],["/2024/09/11/AR预测/index.html","a10fd6abc09c284b3738f27471c20feb"],["/2024/09/11/MA预测/index.html","86efda5df03cd9de70a4f5a7b7afaea6"],["/2024/09/11/SARIMA预测/index.html","2ea4bac0c1f91dd9629926bc8486cfbb"],["/2024/09/11/交通运输工程学课程设计代码/index.html","7d162c7164708165d40807ceab821f55"],["/2024/09/11/排队论模型代码/index.html","62dff8f685e178f795c80643e3a7efd6"],["/2024/09/11/改进的鲸鱼算法代码/index.html","66d1ca9839ceaa60ea88397cc14b891e"],["/2024/09/11/模拟退火算法代码/index.html","c9179a0dbff831abdd2b6eed91727aa3"],["/2024/09/11/灰色预测/index.html","22034ee06ec06792998d132c5653b40b"],["/2024/09/11/粒子群算法代码/index.html","c89a3812c59015f8003ded899f717a02"],["/2024/09/11/结合熵权法的topsis客观评价/index.html","3b537654e8c965ba4db26f577d5e921b"],["/2024/10/01/PDF_math/index.html","3079b37522af459d11056691172f8a51"],["/404.html","444b019d187370320118024f5e80c45b"],["/about/index.html","c1001f27b75606ff7c391f72e3e66fa5"],["/archives/2024/01/index.html","5851f1351fadef6f8bfdd574c13c3900"],["/archives/2024/02/index.html","9d412cb43f2325d864c1066a58868101"],["/archives/2024/07/index.html","c22e8ffa1b67feed5782bd10ae6539ce"],["/archives/2024/09/index.html","4d2b99c4fae8f193a02264d12b859f00"],["/archives/2024/09/page/2/index.html","2a49812e89b18ea1ce162fdc6e47e59c"],["/archives/2024/10/index.html","474d3689ee00890932564f2341a26c68"],["/archives/2024/index.html","22c7e9853a64dbed2ff10c759703b4ea"],["/archives/2024/page/2/index.html","e37708ef70f1584206ffa0a717911829"],["/archives/index.html","f2f3e0bd35a67d2c1a2c6ddb586b1eb5"],["/archives/page/2/index.html","d867f8aa502d93558b3091063b414fe8"],["/categories/index.html","c819478eb980027528b578bb9f62de58"],["/categories/人工智能/index.html","88082c9dcdae84fe3f5efd1563272998"],["/categories/基础工具/index.html","b311f389eb09982a3cd17d2026e2e807"],["/categories/数学建模/index.html","cfd6b1b1491f4727ef3c6153e5085f7c"],["/categories/数学建模/page/2/index.html","b0ecf28ab960e78f26a3a3534babc4f5"],["/categories/游戏/index.html","e506a2ef37f484c672c61354ab5081a4"],["/categories/游戏/自动化/index.html","0c90d7cf7116874adc636bdaf20a58bb"],["/categories/考研408/index.html","62b460f6c4127b436ebaf97afa0db18a"],["/css/gitalk.css","1573fd650b11482f9dd295ed4af024c5"],["/css/highlight-dark.css","fa6d808c194fbe83fa70b5193d0ec41d"],["/css/highlight.css","207b917e3c65ff58f49935eb708c3a5d"],["/css/main.css","7f767f8cc752f996cd6fd8993725180e"],["/img/avatar.png","e4020cb9bc27a52f406fa41c882f5cd1"],["/img/default.png","68977cd063e5d182b3a43614be3d98d8"],["/img/fluid.png","4aed91411d3b02af426592260f4b7b12"],["/img/loading.gif","93e33d89a8cbe54ec945235d25af5607"],["/img/police_beian.png","b769e8dfde5660239317ed60758dba13"],["/index.html","7c939ebf09853039d43c9d31f2855551"],["/js/boot.js","7683fab2fc9d03a3a659aa956b3a54e8"],["/js/color-schema.js","5e4105d10638e64b40820fa28567d0d5"],["/js/events.js","734c9d1a9b78947e2e2e2d8b88c5920b"],["/js/img-lazyload.js","fab30a410e5f490fce3f977a6936a714"],["/js/leancloud.js","fb4a815ccdb5d851d00561dbb62251c4"],["/js/local-search.js","9dc47a0b7b6bacfd16541c9b2b5b6bc5"],["/js/plugins.js","6c10bee3f659ca91b534bf4a81d62f1e"],["/js/utils.js","f7ce9014de1cd7358eeb3aba81c8efe2"],["/links/index.html","684c5f7b398d23d0570d1057315d37a1"],["/page/2/index.html","b6d895c023de587f2c047748541d1438"],["/sw-register.js","3e33b9e4f43ad8631c9da9fdb6ce832f"],["/tags/index.html","47ca4cce3567ee28fcb2fcbfdd62294f"]]; +var precacheConfig = [["/2024/01/09/GitHub desktop基本用法/2023-05-07_232823.png","c24df821a6497444e71b2243e0577a9a"],["/2024/01/09/GitHub desktop基本用法/Untitled 1.png","2fa248a8f262c8636a07d3bd06dcc1fe"],["/2024/01/09/GitHub desktop基本用法/Untitled 10.png","c2154d964d2e468589b86bef5f35d53a"],["/2024/01/09/GitHub desktop基本用法/Untitled 11.png","abda8e93832cdb4fb8b0e6341c8d031f"],["/2024/01/09/GitHub desktop基本用法/Untitled 12.png","3505440efe0f7c43537137fd83adeb14"],["/2024/01/09/GitHub desktop基本用法/Untitled 13.png","46f19d6ccf828fd50d1317069a3aa2bb"],["/2024/01/09/GitHub desktop基本用法/Untitled 14.png","c7d61ce5820b53b7cfb746674160f9c5"],["/2024/01/09/GitHub desktop基本用法/Untitled 15.png","1c74bd4c3c479c6cbb717b5ab7ba9380"],["/2024/01/09/GitHub desktop基本用法/Untitled 16.png","17d74c538216b387e59724648a311cf9"],["/2024/01/09/GitHub desktop基本用法/Untitled 17.png","e61d189ea48bf0684d3c6330cae5b66e"],["/2024/01/09/GitHub desktop基本用法/Untitled 18.png","a0f26d2c02b09e6f98a49b4ed5e92990"],["/2024/01/09/GitHub desktop基本用法/Untitled 19.png","655dace5a204d04f04bb771c1f78f202"],["/2024/01/09/GitHub desktop基本用法/Untitled 2.png","326f9c7a13fe45ec249f127fc0380ccd"],["/2024/01/09/GitHub desktop基本用法/Untitled 20.png","68f746a0060ea6c081d1bf2c1496fb2f"],["/2024/01/09/GitHub desktop基本用法/Untitled 21.png","b1e5ea352441a541703f9d2867bc3841"],["/2024/01/09/GitHub desktop基本用法/Untitled 22.png","9197489c29212235b23d03aaafc12169"],["/2024/01/09/GitHub desktop基本用法/Untitled 23.png","f13175ce125954d6db5235205f48d978"],["/2024/01/09/GitHub desktop基本用法/Untitled 24.png","43e23660e25d8aa2e044c40c459cd400"],["/2024/01/09/GitHub desktop基本用法/Untitled 25.png","138b3364053bb65add68db6669f5d636"],["/2024/01/09/GitHub desktop基本用法/Untitled 26.png","426824e5d019a894a527b700abe629de"],["/2024/01/09/GitHub desktop基本用法/Untitled 27.png","6fcb131534b72e9365601b15cffa56bb"],["/2024/01/09/GitHub desktop基本用法/Untitled 3.png","354fa66f304720bdef613d8096574e32"],["/2024/01/09/GitHub desktop基本用法/Untitled 4.png","cd69f961522f00c1fac975902d60823d"],["/2024/01/09/GitHub desktop基本用法/Untitled 5.png","56c7f45017b1c73b44fe11be74a3b923"],["/2024/01/09/GitHub desktop基本用法/Untitled 6.png","4830b6f9dec4491262ec4335c953bb16"],["/2024/01/09/GitHub desktop基本用法/Untitled 7.png","50613175b6820d882c6b95df34780461"],["/2024/01/09/GitHub desktop基本用法/Untitled 8.png","d8513c20ac045674ba216bca64a1060a"],["/2024/01/09/GitHub desktop基本用法/Untitled 9.png","4305232b7f50b2c39bebbdcf89f10117"],["/2024/01/09/GitHub desktop基本用法/Untitled.png","af1264ba3284f0a578c35ca704f2ab4f"],["/2024/01/09/GitHub desktop基本用法/index.html","c6862d55cf4cc5e0cbd12ce01097a36d"],["/2024/01/10/人工智能学习导航/index.html","298b976ab331ef38952b011396e40afe"],["/2024/01/12/python程序带图片等资源打包/index.html","3ea0547664bdfba569e2a7f2c27c61f1"],["/2024/02/02/数据结构之线性表代码/index.html","8934895b03624ddcbc9c79c116f19540"],["/2024/02/03/数据结构之栈与队列代码/index.html","3b911c5ed4c38952c475a9aa789f2fd5"],["/2024/07/21/生死狙击2净化行动挂机脚本/index.html","6f80be9eca2347f845202b021498be3b"],["/2024/09/11/ARIMA预测/index.html","d742700c70eb77899c83839d40bfbe96"],["/2024/09/11/ARMA预测/index.html","8e30860935a3bd3e4b4aab1f960b7ed7"],["/2024/09/11/AR预测/index.html","a10fd6abc09c284b3738f27471c20feb"],["/2024/09/11/MA预测/index.html","86efda5df03cd9de70a4f5a7b7afaea6"],["/2024/09/11/SARIMA预测/index.html","2ea4bac0c1f91dd9629926bc8486cfbb"],["/2024/09/11/交通运输工程学课程设计代码/index.html","7d162c7164708165d40807ceab821f55"],["/2024/09/11/排队论模型代码/index.html","62dff8f685e178f795c80643e3a7efd6"],["/2024/09/11/改进的鲸鱼算法代码/index.html","66d1ca9839ceaa60ea88397cc14b891e"],["/2024/09/11/模拟退火算法代码/index.html","c9179a0dbff831abdd2b6eed91727aa3"],["/2024/09/11/灰色预测/index.html","22034ee06ec06792998d132c5653b40b"],["/2024/09/11/粒子群算法代码/index.html","c89a3812c59015f8003ded899f717a02"],["/2024/09/11/结合熵权法的topsis客观评价/index.html","3b537654e8c965ba4db26f577d5e921b"],["/2024/10/01/PDF_math/index.html","3079b37522af459d11056691172f8a51"],["/404.html","444b019d187370320118024f5e80c45b"],["/about/index.html","c1001f27b75606ff7c391f72e3e66fa5"],["/archives/2024/01/index.html","5851f1351fadef6f8bfdd574c13c3900"],["/archives/2024/02/index.html","9d412cb43f2325d864c1066a58868101"],["/archives/2024/07/index.html","c22e8ffa1b67feed5782bd10ae6539ce"],["/archives/2024/09/index.html","4d2b99c4fae8f193a02264d12b859f00"],["/archives/2024/09/page/2/index.html","2a49812e89b18ea1ce162fdc6e47e59c"],["/archives/2024/10/index.html","474d3689ee00890932564f2341a26c68"],["/archives/2024/index.html","22c7e9853a64dbed2ff10c759703b4ea"],["/archives/2024/page/2/index.html","e37708ef70f1584206ffa0a717911829"],["/archives/index.html","f2f3e0bd35a67d2c1a2c6ddb586b1eb5"],["/archives/page/2/index.html","d867f8aa502d93558b3091063b414fe8"],["/categories/index.html","c819478eb980027528b578bb9f62de58"],["/categories/人工智能/index.html","88082c9dcdae84fe3f5efd1563272998"],["/categories/基础工具/index.html","b311f389eb09982a3cd17d2026e2e807"],["/categories/数学建模/index.html","cfd6b1b1491f4727ef3c6153e5085f7c"],["/categories/数学建模/page/2/index.html","b0ecf28ab960e78f26a3a3534babc4f5"],["/categories/游戏/index.html","e506a2ef37f484c672c61354ab5081a4"],["/categories/游戏/自动化/index.html","0c90d7cf7116874adc636bdaf20a58bb"],["/categories/考研408/index.html","62b460f6c4127b436ebaf97afa0db18a"],["/css/gitalk.css","1573fd650b11482f9dd295ed4af024c5"],["/css/highlight-dark.css","fa6d808c194fbe83fa70b5193d0ec41d"],["/css/highlight.css","207b917e3c65ff58f49935eb708c3a5d"],["/css/main.css","7f767f8cc752f996cd6fd8993725180e"],["/img/avatar.png","e4020cb9bc27a52f406fa41c882f5cd1"],["/img/default.png","68977cd063e5d182b3a43614be3d98d8"],["/img/fluid.png","4aed91411d3b02af426592260f4b7b12"],["/img/loading.gif","93e33d89a8cbe54ec945235d25af5607"],["/img/police_beian.png","b769e8dfde5660239317ed60758dba13"],["/index.html","7c939ebf09853039d43c9d31f2855551"],["/js/boot.js","7683fab2fc9d03a3a659aa956b3a54e8"],["/js/color-schema.js","5e4105d10638e64b40820fa28567d0d5"],["/js/events.js","734c9d1a9b78947e2e2e2d8b88c5920b"],["/js/img-lazyload.js","fab30a410e5f490fce3f977a6936a714"],["/js/leancloud.js","fb4a815ccdb5d851d00561dbb62251c4"],["/js/local-search.js","9dc47a0b7b6bacfd16541c9b2b5b6bc5"],["/js/plugins.js","6c10bee3f659ca91b534bf4a81d62f1e"],["/js/utils.js","f7ce9014de1cd7358eeb3aba81c8efe2"],["/links/index.html","684c5f7b398d23d0570d1057315d37a1"],["/page/2/index.html","b6d895c023de587f2c047748541d1438"],["/sw-register.js","9d921e9902651b12e4ac07d4269d8b82"],["/tags/index.html","47ca4cce3567ee28fcb2fcbfdd62294f"]]; var cacheName = 'sw-precache-v3--' + (self.registration ? self.registration.scope : ''); var firstRegister = 1; // 默认1是首次安装SW， 0是SW更新 diff --git a/tags/index.html b/tags/index.html index ab66a9a..47bb513 100644 --- a/tags/index.html +++ b/tags/index.html @@ -1 +1,14 @@ -标签 - 马锦的博客
\ No newline at end of file +标签 - 马锦的博客
+ + \ No newline at end of file