很难找的基于模糊控制的程序源代码
单片机 模糊控制pid 源代码
单片机模糊控制pid 源代码1. 单片机模糊控制PID的基本原理单片机模糊控制PID是一种基于模糊控制理论和PID控制理论相结合的控制方法。
其基本原理是通过模糊控制算法对系统进行模糊化处理，将输入和输出都转化为模糊量，然后再利用PID控制算法对模糊量进行处理，最终得到控制量，从而实现对系统的控制。
2. 单片机模糊控制PID的源代码实现单片机模糊控制PID的源代码实现需要先进行模糊化处理，然后再进行PID控制计算。
下面是一个基于C语言的单片机模糊控制PID的源代码示例：```#include <stdio.h>#include <stdlib.h>#include <math.h>//模糊化处理函数float fuzzy(float error){float fuzzy_error = 0;if(error < -10)fuzzy_error = -1;else if(error >= -10 && error < -5)fuzzy_error = (error + 10) / 5;else if(error >= -5 && error <= 5)fuzzy_error = 0;else if(error > 5 && error <= 10)fuzzy_error = (error - 5) / 5;else if(error > 10)fuzzy_error = 1;return fuzzy_error;}//PID控制函数float PID(float error, float last_error, float sum_error) {float kp = 0.5;float ki = 0.1;float kd = 0.2;float p = kp * error;float i = ki * sum_error;float d = kd * (error - last_error);return p + i + d;}int main(){float error = 0;float last_error = 0;float sum_error = 0;float control = 0;for(int i = 0; i < 100; i++){error = 10 - i;float fuzzy_error = fuzzy(error);sum_error += error;control = PID(fuzzy_error, last_error, sum_error);last_error = error;printf("control: %f\n", control);}return 0;}```3. 单片机模糊控制PID的应用场景单片机模糊控制PID可以应用于各种需要精确控制的场景，例如温度控制、机器人控制、电机控制等。
模糊PID控制温控系统设计C语言程序代码
模糊PID控制温控系统设计C语言程序代码介绍本文介绍了使用模糊PID控制方法来设计温控系统的C语言程序代码。
本温控系统使用传感器读取室内温度，然后根据读取的数值对应调整冷风机的风速和加热器的加热时间，从而控制室内温度达到一个设定值。
系统设计本温控系统采用模糊PID控制方法，具体实现流程如下：1.根据设定温度和当前室内温度计算出误差值2.使用模糊控制方法将误差值转化为温度调节量3.根据模糊控制输出的温度调节量计算出PID控制器的输出4.根据PID控制器的输出调节冷风机的风速和加热器的加热时间系统设计中需要使用的传感器，冷风机和加热器的具体型号及参数需要根据实际情况进行选择。
此处不做详细说明。
程序代码实现以下代码实现了上述系统设计，包括模糊控制和PID控制。
// 温控系统C语言程序代码#include<stdio.h>#include<stdlib.h>// 模糊控制double GetTemperatureByFuzzy(double error){double delta = 0.5; // 设定的温度调节步长double result = 0;if (error <= -5){result = 1;}else if (error > -5 && error < 0){result = (error + 5) / 5.0;}else if (error >= 0 && error < 5){result = (5 - error) / 5.0;}else{result = 0;}return result * delta;}// PID控制double GetTemperatureByPID(double error, double lastError, double integ ral){double Kp = 0.5; // 比例系数double Ki = 0.01; // 积分系数double Kd = 0.1; // 微分系数double deltaT = 0.1; // 采样时间double derivate = (error - lastError) / deltaT;double result = Kp * error + Ki * integral + Kd * derivate;return result;}// 主函数int main(){double setTemp = 25; // 设定温度double curTemp = 24; // 当前温度，需要从传感器读取double lastError = 0; // 上一次的误差值double integral = 0; // 积分项while (1){double error = setTemp - curTemp; // 计算当前误差值double fuzzyTemp = GetTemperatureByFuzzy(error); // 模糊控制integral += error; // 更新积分项double pidTemp = GetTemperatureByPID(error, lastError, integra l); // PID控制lastError = error; // 更新上一次误差值// 根据pidTemp和fuzzyTemp调节冷风机的风速和加热器的加热时间，省略// 读取传感器更新当前温度，省略// curTemp = GetCurTemp();// 采样时间，省略// sleep(1);}}本文介绍了使用模糊PID控制方法来设计温控系统的C语言程序代码。
基于MSP430和模糊PID油田注水流量控制系统
不及其他工艺工程 ， 注水方法 和装备相 对落 后 ， 近年来 ， 随着我
国各 主 力 油 田 已 相 继 进 入 高 或 特 高 含 水 期 ， 油 速 度 变 缓 、 采 含 水 上 升 加 快 、 量 逐 步 下 降 、 本 上 升 的 矛 盾 已无 法 回 避 ， 过 产 成 通
１ 脚的 Ｔ ＿ ２ １ ＿ ２０封装 中 ， 由分 立元件 构成 的桥式驱 动 电路 相 与 比，ＭＤ ８０ Ｌ １２ ０构成的驱动 电路结构简化 ， 内设 过热报警输 出和
自动关 断保 护 电 路 ， 能 更 加 可 靠 。 Ｌ 性 ＭＤＩ２ ０可 采 用 ２种 不 ８０
用检测 仪器 、电机 控制 、家 庭 自动化 等 领域得 到 了广 泛 的应
集 电路 、Ｃ Ｌ Ｄ显 示 电 路 、 盘 电 路 等 。 键
２ １ 以单 片 机 为 核 心 的 控 制 系统 ．
接触的材料 为高合金钢 ， 耐磨耐腐蚀 ， 积相 对较小 ， 体 测量精度
能达 到 １ 左 右 。 ％ ２ ５ 电 机 控 制 ． 驱 动 电路 为 用 于 电机 驱 动 的功 率 集 成 芯 片 Ｌ １２ ０ 它 ＭＤ ８ ０ 。
系 统 由微 功 耗 单 片 机 系 统 、 门控 制 、 源 管 理 模 块 、 Ｃ 阀 电 ＬＤ
显示 、 Ｐ Ｓ 块 等 部 分 组 成 。 系 统 图 的 硬 件 原 理 框 图 如 图 １ ＧＲ 模
所示。
工作 原 理 ： 统 以 ＭＳ ４ ０ １９为 核 心 ， 统 大 部 分 时 问 都 系 Ｐ ３Ｆ４ 系 处 于 低 功 耗 模 式 Ｌ Ｍ０ 当定 时 中 断 到 来 时 ， 醒 Ｃ Ｕ进 入 工 作 Ｐ ， 唤 Ｐ 周期 开 始 新 一 轮 采 集 压 力 、 量 信 号 ， 流 当完 成 采 集 信 号 的 转 换
自动化控制系统中的模糊控制方法与调参技巧
自动化控制系统中的模糊控制方法与调参技巧自动化控制系统中的模糊控制方法是一种基于模糊逻辑的控制策略，可以处理系统模型复杂、不确定性强的问题。
模糊控制方法通过将模糊逻辑应用于控制器设计中，能够有效地应对实际系统中的各种非线性、时变和不确定性因素，提高控制系统的鲁棒性和自适应能力。
在模糊控制系统中，模糊逻辑通过将模糊的自然语言规则转化为数学形式，对系统的输入和输出进行模糊化处理，从而实现对系统的自动控制。
模糊控制方法主要包括模糊推理、模糊建模和模糊控制器设计三个主要步骤。
首先，模糊推理是模糊控制方法的核心，它根据一组模糊规则对输入变量进行模糊推理，从而确定最终的控制策略。
在模糊推理中，需要定义一组模糊规则，每个模糊规则都由若干个模糊集和若干个模糊关系所组成。
通过对输入变量的模糊化处理和模糊规则的匹配，可以得到控制器的输出。
其次，模糊建模是模糊控制方法的前提，它是将实际系统映射为模糊控制系统的关键步骤。
模糊建模可以通过实验数据、专家知识或模型等方式获得系统的输入输出数据，然后利用聚类和拟合等方法建立系统的模糊模型。
模糊建模的目的是找到系统的内在规律和数学模型，以便后续的模糊控制器设计和参数调优。
最后，模糊控制器设计是模糊控制方法的具体实现，它根据模糊推理和模糊建模的结果，确定模糊控制器的结构和参数。
模糊控制器的结构包括输入变量的模糊集合和输出变量的模糊集合，参数则决定了模糊控制器的具体行为。
参数调优是模糊控制器设计的关键环节，通过合理地设置参数，可以使模糊控制器在实际系统中具有良好的控制性能和鲁棒性。
为了获得较好的控制性能，模糊控制系统中的调参技巧是必不可少的。
调参技巧通常包括以下几个方面：首先，选取适当的输入变量和输出变量，并对其进行模糊化处理。
输入变量和输出变量的选择应考虑到系统的特性和控制目标，而模糊化处理的方法则可以采用三角函数、梯形函数等常用的模糊集合类型。
其次，确定模糊规则的数量和形式。
模糊规则的数量和形式直接影响到模糊控制系统的稳定性和鲁棒性。
基于PLC的模糊控制器设计及Simulink仿真
64 | 电子制作 2021年02月热能，当电流流过电阻材料时，电能转换成热能，产生热量，再通过热的传导、对流、辐射，能有效地用来加热特定的试验件，并保持高的效率，此种加热方式称为辐射加温。
辐射加热具有热转换率高、加热温度高等优点，因此是试验车台上使用最广泛的一种加热方式。
温度是试验任务中一项很重要的监控指标，很多试验任务要求在特定的温度下才能进行，实际温度值和控制的精度、准确度决定了试验能否进行下去，因此研究温度控制工作原理，寻找合适的控制算法具有重要意义。
辐射加温控制系统是典型的一阶纯滞后环节，可用一阶惯性环节加滞后环节表示，具有升温单向性、大惯性、纯滞后、非线性和时变性等特点，用传统控制方式易导致超调大、调节时间长、控制精度低。
其升温、保温是依靠电阻丝加热，当其温度一旦超调就无法用控制手段使其降温。
理论和经验表明，传统的PID 控制对温度控制系统无法达到理想效果[1-2]。
模糊控制是目前十分成熟的一种智能控制方法，其采用模糊逻辑把人的控制经验归纳为定性描述的一组条件语言，利用模糊集理论，将其定量化，使控制器模仿人的操作策略，模糊控制具有很强的鲁棒性和稳定性，大量的理论研究和实践也充分证明了用模糊控制理论控制电阻炉温度是一种非常好的方法策略[3]。
PLC 具有通用性好、性能可靠、编程灵活、扩展方便等优点，在工业控制中广泛使用，PLC 指令越来越强大，能够实现许多复杂的控制算法，利用PLC 实现模糊控制，结合二者的长处，在工业控制中大有前景。
基于上述，本文提出在PLC 平台上将模糊控制方法和常规PID 控制结合的控制策略。
1 控制策略当实际温度值和给定温度值偏差较大时，采用模糊控制合式控制策略，既可以保证系统动态响应效果，又能改善稳态控制精度，系统控制框图如图1所示。
其中S 为转换开关，其设定值一般取最大误差的10%，本文取20，即给定值和实际值偏差在20℃以内采用PID 控制，超过20℃采用模糊[4]模糊控制器能在线对PID 参数进行修改，进一步完善了传统PID 控制器的性能，更好的适应控制系统参数变化和工作条件，如图1所示，模糊控制器由模糊化，模糊推理和解模糊三个环节构成，将工程上的精确量转换为模糊输入信息，利用模糊规则进行模糊推理，经解模糊后转换为精确值，送到被控对象。
模糊逻辑与模糊控制的基本原理
模糊逻辑与模糊控制的基本原理在现代智能控制领域中，模糊逻辑与模糊控制是研究的热点之一。
模糊逻辑可以应用于形式化描述那些非常复杂，无法准确或完全定义的问题，例如语音识别、图像处理、模式识别等。
而模糊控制可以通过模糊逻辑的方法来设计控制系统，对那些难以表达精确数学模型的问题进行控制，主要用于不确定的、非线性的、运动系统模型的控制。
本文主要介绍模糊逻辑和模糊控制的基本原理。
一、模糊逻辑的基本原理模糊逻辑是对布尔逻辑的延伸，在模糊逻辑中，各种概念之间的相互关系不再是严格的，而是模糊的。
模糊逻辑的基本要素是模糊集合，模糊集合是一个值域在0和1之间的函数，它描述了一个物体属于某个事物的程度。
以温度为例，一般人将15℃以下的温度视为冷，20至30℃为暖，30℃以上为热。
但是在模糊逻辑中，这些概念并不是非黑即白，而可能有一些模糊的层次，如18℃可能既不是冷又不是暖，但是更接近于暖。
因此，设180℃该点的温度为x，则可以用一个图形来描述该温度与“暖”这个概念之间的关系，这个图形称为“隶属函数”或者“成员函数”图。
一个隶属函数是一个可数的、从0到1变化的单峰实函数。
它描述了一个物体与一类对象之间的相似程度。
对于温度为18℃的这个例子，可以用一个隶属函数来表示其与“暖”这一概念之间的关系。
这个隶属函数，可以用三角形或者梯形函数来表示。
模糊逻辑还引入了模糊关系和模糊推理的概念。
模糊关系是对不确定或模糊概念间关系的粗略表示，模糊推理是指通过推理机来对模糊逻辑问题进行判断和决策。
二、模糊控制的基本原理在控制系统中，通常采用PID控制或者其他经典控制方法来控制系统，但对于一些非线性控制系统，这些方法越发显得力不从心。
模糊控制是一种强大的、在处理非线性系统方面表现出色的控制方法。
它通过对遥测信号进行模糊化处理，并将模糊集合控制规则与一系列的控制规则相关联起来以实现控制。
模糊控制的基本组成部分主要包括模糊化、模糊推理、去模糊化等三个步骤。
模糊控制c++代码
模糊控制c++代码以下是一个简单的模糊控制 C++代码示例，用于演示基本的模糊控制系统：```cpp#include <iostream>#include <vector>using namespace std;// 模糊控制系统的输入变量struct FuzzyInput {double temperature;double humidity;};// 模糊控制系统的输出变量struct FuzzyOutput {double fanSpeed;};// 定义模糊集合及其隶属度函数struct FuzzySet {string name;vector<double> membershipFunctions;};// 模糊规则struct FuzzyRule {string ifClause;string thenClause;};// 初始化模糊集合FuzzySet cold = {"cold", {0.0, 0.0, 5.0, 10.0}};FuzzySet cool = {"cool", {0.0, 5.0, 10.0, 15.0}};FuzzySet warm = {"warm", {5.0, 10.0, 15.0, 20.0}};FuzzySet hot = {"hot", {10.0, 15.0, 20.0, 25.0}};// 初始化模糊规则FuzzyRule rule1 = {"if temperature is cold and humidity is low", "then fanSpeed is low"};FuzzyRule rule2 = {"if temperature is cool and humidity is low", "then fanSpeed is medium"};FuzzyRule rule3 = {"if temperature is warm and humidity is low", "then fanSpeed is high"};FuzzyRule rule4 = {"if temperature is hot and humidity is low", "then fanSpeed is very high"};FuzzyRule rule5 = {"if temperature is cold and humidity is high", "then fanSpeed is medium"};FuzzyRule rule6 = {"if temperature is cool and humidity is high", "then fanSpeed is high"};FuzzyRule rule7 = {"if temperature is warm and humidity is high", "then fanSpeed is very high"};FuzzyRule rule8 = {"if temperature is hot and humidity is high", "then fanSpeed is very high"};// 模糊推理引擎void fuzzyInference(FuzzyInput input, vector<FuzzyRule> rules, FuzzyOutput& output) {// 计算输入变量的模糊隶属度double temperatureMembership =隶属度计算(input.temperature, cold.membershipFunctions, cool.membershipFunctions, warm.membershipFunctions, hot.membershipFunctions);double humidityMembership =隶属度计算(input.humidity, cold.membershipFunctions, cool.membershipFunctions, warm.membershipFunctions, hot.membershipFunctions);// 遍历每条规则并进行推理for (FuzzyRule rule : rules) {string ifClause = rule.ifClause;string thenClause = rule.thenClause;// 提取规则的条件部分string temperature = ifClause.substr(0, ifClause.find("and"));string humidity = ifClause.substr(ifClause.find("and") + 3);// 计算条件部分的满足度double temperatureSatisfaction = temperatureMembership[std::stoi(temperature)];double humiditySatisfaction = humidityMembership[std::stoi(humidity)];// 计算规则的总满足度double satisfaction = temperatureSatisfaction * humiditySatisfaction;// 提取规则的结论部分string fanSpeed = thenClause;// 更新输出变量的模糊隶属度output.fanSpeed[std::stoi(fanSpeed)] = satisfaction;}}// 隶属度计算函数double 隶属度计算(double x, vector<double> membershipFunctions, vector<double> membershipFunctions, vector<double> membershipFunctions, vector<double> membershipFunctions) {// 检查输入是否在模糊集合的定义域内if (x < membershipFunctions[0] || x > membershipFunctions[3]) {return 0.0;}// 计算模糊隶属度double membership = 0.0;for (int i = 0; i < 4; i++) {if (membershipFunctions[i] <= x && x < membershipFunctions[i + 1]) { membership = membershipFunctions[i + 1] - x;membership /= (membershipFunctions[i + 1] - membershipFunctions[i]);break;}}return membership;}int main() {FuzzyInput input = {22.0, 60.0};FuzzyOutput output;// 定义模糊规则vector<FuzzyRule> rules = {rule1, rule2, rule3, rule4, rule5, rule6, rule7, rule8};// 进行模糊推理fuzzyInference(input, rules, output);// 输出模糊推理结果cout << "Fan Speed: " << output.fanSpeed << endl;return 0;}```上述代码是一个简单的模糊控制系统，用于根据输入的温度和湿度来控制风扇的速度。
模糊pid控制-python实现
模糊pid控制 python实现模糊PID控制（Fuzzy PID control）是一种基于模糊逻辑的控制方法，它结合了模糊控制和经典PID控制的优点，可以在复杂和不确定的环境中实现精确的控制。
本文将介绍模糊PID控制的原理、实现方法以及在Python中的应用。
一、模糊PID控制的原理PID控制是一种经典的控制方法，它通过比较实际输出与期望输出之间的误差，根据比例、积分和微分三个参数进行调节，使系统输出逐渐趋近于期望值。
然而，传统的PID控制方法在面对非线性、时变和不确定性系统时表现不佳。
模糊PID控制通过引入模糊逻辑来解决传统PID控制的问题。
模糊逻辑是一种能够处理模糊信息的数学方法，它可以将模糊的输入映射到模糊的输出。
模糊PID控制器通过将误差、误差变化率和误差积分三个输入量模糊化，然后根据一组模糊规则进行推理，得到模糊输出。
最后，通过解模糊化的方法将模糊输出转化为具体的控制量。
二、模糊PID控制的实现方法1. 模糊化模糊化是将具体的输入量映射到模糊集合上的过程。
常用的模糊化方法有三角隶属函数、梯形隶属函数和高斯隶属函数等。
根据具体的问题和经验，选择合适的隶属函数进行模糊化。
2. 规则库规则库是模糊PID控制的核心。
它包含了一组模糊规则，用于根据输入量的模糊值推理出输出量的模糊值。
模糊规则一般采用IF-THEN的形式，例如“IF 误差是A1 AND 误差变化率是B2 THEN 输出是C3”。
规则库的设计需要根据具体问题进行，可以基于经验或者专家知识。
3. 推理机制推理机制是根据模糊规则进行推理的过程。
常用的推理方法有最大最小合成、模糊推理和模糊推理和等。
推理机制将模糊输入与规则库进行匹配，然后根据匹配的程度计算出模糊输出的隶属度。
4. 解模糊化解模糊化是将模糊输出转化为具体的控制量的过程。
常用的解模糊化方法有最大隶属度法、面积法和重心法等。
解模糊化方法根据模糊输出的隶属度分布，计算出具体的控制量。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include<iostream.h>#include<iomanip.h>#include<fstream.h>#include<stdlib.h>struct Fzb{int yyz; //语言之int ly; //论域float lsd; //隶属值struct Fzb *next;};class Fuzzy{private:int g[49][3]; //定义了规则库，用于函数间调用float R[169][13]; //定义了关系矩阵，用于函数间调用float H[13][13]; //定义了查询表矩阵，用于函数间的调用public:struct Fzb * Creatfzb(); //建立赋值表函数void Printfzb(struct Fzb *head1); //输出赋值表void Inputgzk(); //导入规则库void jlgx(struct Fzb*E,struct Fzb*EC,struct Fzb*U); //建立关系矩阵void jlcxb(struct Fzb*E,struct Fzb*EC,struct Fzb*U); //建立查询表};struct Fzb *Fuzzy::Creatfzb(){float f[8][14]={{0,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6},{-3,1,0.5,0,0,0,0,0,0,0,0,0,0,0},{-2,0,0.5,1,0.5,0,0,0,0,0,0,0,0,0},{-1,0,0,0,0.5,1,0.5,0,0,0,0,0,0,0},{0,0,0,0,0,0,0.5,1,0.5,0,0,0,0,0},{1,0,0,0,0,0,0,0,0.5,1,0.5,0,0,0},{2,0,0,0,0,0,0,0,0,0,0.5,1,0.5,0},{3,0,0,0,0,0,0,0,0,0,0,0,0.5,1}}; //默认输入赋值表int i,k,j;fstream in,out;struct Fzb *head,*p1,*p2;int n=0;head=NULL;p1=new(Fzb);for(k=1;k<8;k++)for(j=1;j<14;j++){n++;p1->lsd=f[k][j];p1->yyz=(int)f[k][0];p1->ly=(int)f[0][j];if(1==n) head=p1;p2=p1;p1=new(Fzb);p2->next=p1;}p2->next=NULL;int m=0;return (head);}void Fuzzy::Inputgzk(){int G[49][3]={{-3,-3,-3},{-3,-2,-3},{-3,-1,-3},{-3,0,-3},{-3,1,-2},{-3,2,0},{-3,3,0},{-2,-3,-3},{-2,-2,-3},{-2,-1,-3},{-2,0,-3},{-2,1,-2},{-2,2,0},{-2,3,0},{-1,-3,-2},{-1,-2,-2},{-1,-1,-2},{-1,0,-2},{-1,1,0},{-1,2,1},{-1,3,1},{0,-3,-2},{0,-2,-2},{0,-1,-1},{0,0,0},{0,1,1},{0,2,2},{0,3,2},{1,-3,-1},{1,-2,-1},{1,-1,0},{1,0,2},{1,1,2},{1,2,2},{1,3,2},{2,-3,0},{2,-2,0},{2,-1,2},{2,0,3},{2,1,3},{2,2,3},{2,3,3},{3,-3,0},{3,-2,0},{3,-1,2},{3,0,3},{3,1,3},{3,2,3},{3,3,3}}; //默认输入规则库int i,j;int n=0;for(i=0;i<49;i++)for(j=0;j<3;j++){n++;g[i][j]=G[i][j];cout<<setw(5)<<g[i][j]; //显示规则库if(3==n) {cout<<endl;n=0;}}}void Fuzzy::Printfzb(struct Fzb *head1){struct Fzb *p;p=head1;int n,i,j;float a[8][14];while(NULL!=p){a[p->yyz+4][p->ly+7]=p->lsd;p=p->next;}p=head1;while (NULL!=p){a[0][p->ly+7]=p->ly;p=p->next;}p=head1;while (NULL!=p){a[p->yyz+4][0]=p->yyz;p=p->next;}a[0][0]=0;int k;for(i=0;i<8;i++) //用于输出标准形式的赋值表{n=0;for(j=0;j<14;j++){n++;if(0==j&&0!=i){switch((int)a[i][j]) {case -3:cout<<setw(5)<<"NB";break;case -2:cout<<setw(5)<<"NM";break;case -1:cout<<setw(5)<<"NS";break;case 0:cout<<setw(5)<<"Z";break;case 1:cout<<setw(5)<<"PS";break;case 2:cout<<setw(5)<<"PM";break;case 3:cout<<setw(5)<<"PB";}}elsecout<<setw(5)<<a[i][j];if(14==n) cout<<endl;}}}void Fuzzy::jlgx(struct Fzb*E,struct Fzb*EC,struct Fzb*U){int i,j,k,m,n,l,z;struct Fzb*p1,*p2,*p3;p1=E; p2=EC; p3=U;float a[13],b[13],c[13];float R1[169],R2[169][13]; //前者用于存储转置后的一维向量，后者用于暂时存储每条规则生成的关系矩阵for(i=0;i<49;i++){p1=E; p2=EC; p3=U;k=0;m=0;n=0;z=0;while(NULL!=p1){if(p1->yyz==g[i][0])a[k++]=p1->lsd;p1=p1->next;}while(NULL!=p2){if(p2->yyz==g[i][1])b[m++]=p2->lsd;p2=p2->next;}while(NULL!=p3){if(p3->yyz==g[i][2])c[n++]=p3->lsd;p3=p3->next;}for(j=0;j<13;j++)for(l=0;l<13;l++){if(a[j]>b[l])R1[z++]=b[l];elseR1[z++]=a[j];}for(j=0;j<169;j++)for(l=0;l<13;l++){if(R1[j]>c[l])R2[j][l]=c[l];elseR2[j][l]=R1[j];}if(0==i)for(j=0;j<169;j++) //以下于对所有规则对应的关系矩阵作加法 for(l=0;l<13;l++){R[j][l]=R2[j][l];}for(j=0;j<169;j++)for(l=0;l<13;l++){if(R2[j][l]>R[j][l])R[j][l]=R2[j][l];}}i=0;for(j=0;j<169;j++)for(l=0;l<13;l++){i++;cout<<setw(5)<<R[j][l]; //输出总的关系矩if(13==i){cout<<endl;i=0;}}return;}void Fuzzy::jlcxb(struct Fzb*E,struct Fzb*EC,struct Fzb*U){int e,ec,u;int i,j,k,n=0,l=0,x=0;float m=0;struct Fzb*p1,*p2,*p3;p1=E;p2=EC;p3=U;float a[13],b[13];float gg[169];float max=0,min;float t[13]; //用于存储每次生成的U的隶属函数，从而求得每组e,ec对应的u for(i=0;i<13;i++)for(j=0;j<13;j++){m=0;p1=E;p2=EC;p3=U;l=0;e=i-6;ec=j-6;while (NULL!=p1){if(e<0){if(e==p1->ly&&m<p1->lsd){n=p1->yyz;m=p1->lsd;}}else{if(e==p1->ly&&m<=p1->lsd){n=p1->yyz;m=p1->lsd;}}p1=p1->next;}p1=E;while (NULL!=p1){if(n==p1->yyz) a[l++]=p1->lsd; p1=p1->next;}m=0;while (NULL!=p2){if(ec<0){if(ec==p2->ly&&m<p2->lsd) {n=p2->yyz;m=p2->lsd;}}else{if(ec==p2->ly&&m<=p2->lsd) {n=p2->yyz;m=p2->lsd;}}p2=p2->next;}p2=EC;l=0;while (NULL!=p2){if(n==p2->yyz) b[l++]=p2->lsd; p2=p2->next;}/*cout<<e<<" "<<ec<<endl;for(x=0;x<13;x++){cout<<a[x]<<" ";}cout<<endl;for(x=0;x<13;x++){cout<<b[x]<<" ";}cout<<endl;*/n=0;for(x=0;x<13;x++)for(l=0;l<13;l++){if(a[x]<b[l]) gg[n++]=a[x];else gg[n++]=b[l];}for(x=0;x<13;x++) //进行推理合成规则计算{max=0;for(l=0;l<169;l++){if(gg[l]<R[l][x]) min=gg[l];else min=R[l][x];if(max<min) max=min;}t[x]=max;}p3=U;float sum=0;float s=0;float u=0;for(x=0;x<13;x++){if(0!=t[x]){s=x-6;sum+=t[x]*s;u+=t[x];}}H[i][j]=sum/u;}for(i=0;i<13;i++){for(j=0;j<13;j++){if(H[i][j]<0)cout<<setw(4)<<(int)(H[i][j]-0.5);elsecout<<setw(4)<<(int)(H[i][j]+0.5);}cout<<endl;}}void main(){struct Fzb *E,*EC,*U;E=EC=U=NULL;Fuzzy p;int jg;int n=1;E=p.Creatfzb(); //默认建立E的赋值表EC=p.Creatfzb(); //默认建立EC的赋值表U=p.Creatfzb(); //默认建立U的赋值表int t=1;while (1==1) {cout<<endl<<"想做什么："<<endl<<"1、输出E的赋值表"<<endl<<"2、输出EC的赋值表"<<endl<<"3、输出U的赋值表"<<endl<<"4、显示规则库"<<endl<<"5、求解关系函数"<<endl<<"6、输出查询表"<<endl<<"6、退出"<<endl;cout<<"----> ";cin>>jg;switch(jg) {case 1:cout<<"*************************************************************"<<endl; cout<<"E的赋值表如下："<<endl;p.Printfzb(E);break;case 2:cout<<"*************************************************************"<<endl; cout<<"EC的赋值表如下："<<endl;p.Printfzb(EC);break;case 3:cout<<"*************************************************************"<<endl; cout<<"U的赋值表如下："<<endl;p.Printfzb(U);break;case 4:p.Inputgzk();n=0;break;case 5:if(n){cout<<"*************************************************************"<<endl; cout<<" 未调入规则库，请先运行步骤4"<<'\a'<<endl;cout<<"*************************************************************"<<endl; }else{p.jlgx(E,EC,U);t=0;}break;case 6:if(t){cout<<"*************************************************************"<<endl; cout<<" 未创建关系矩阵，请先运行步骤5"<<'\a'<<endl;cout<<"*************************************************************"<<endl; }else{cout<<"*************************************************************"<<endl; cout<<"查询表如下："<<endl;p.jlcxb(E,EC,U);}break;default:return;}}}。