请用隶属函数仿真: x∈[5,15]。 利用matlab软件的plot函数，同时画出3个隶属函数。 、三角形隶属函数， 参数为:6,11,14 2、梯形隶属函数，参数为:6,7,14,15 3、高斯隶属函数，参数为:4,8

好的，我会按照您的要求进行回答。下面是MATLAB代码和隶属函数图示：

x = 0:0.1:20;   % 定义x轴范围
y1 = trimf(x, [6 11 14]);   % 定义三角形隶属函数
y2 = trapmf(x, [6 7 14 15]);   % 定义梯形隶属函数
y3 = gaussmf(x, [4 8]);   % 定义高斯隶属函数

figure;
plot(x, y1, 'LineWidth', 2);
hold on;
plot(x, y2, 'LineWidth', 2);
plot(x, y3, 'LineWidth', 2);
ylim([-0.1 1.1]);   % 定义y轴范围
legend('三角形隶属函数', '梯形隶属函数', '高斯隶属函数');

图示如下：


相关问题

设计被控对象为二阶过阻尼传递函数的三输入单输出的模糊控制器的M语言仿真，采用三角形隶属度函数，划分五个模糊子集，在解模糊之前将控制器的输出权值用S函数变换，再用重心法解模糊，绘制隶属度函数图像和仿真图象，编写完整代码

以下是基于Matlab的模糊控制器的代码实现，其中使用了三角形隶属度函数，划分了五个模糊子集，并使用S函数变换和重心法解模糊：

% 设计被控对象为二阶过阻尼传递函数的三输入单输出的模糊控制器的M语言仿真
% 采用三角形隶属度函数，划分五个模糊子集，在解模糊之前将控制器的输出权值用S函数变换，再用重心法解模糊
% 绘制隶属度函数图像和仿真图象，编写完整代码

close all;clear all;clc

% 设定被控对象传递函数的参数
Wn = 1;
Zeta = 0.5;

% 设定模糊控制器的输入变量范围
e_range = [-2, 2];  % 误差范围
ec_range = [-2, 2]; % 误差变化率范围
u_range = [-10, 10]; % 控制量范围

% 设定模糊子集
e = linspace(e_range(1), e_range(2), 5);     % 误差
ec = linspace(ec_range(1), ec_range(2), 5);  % 误差变化率
u = linspace(u_range(1), u_range(2), 5);     % 控制量

% 设定模糊控制器的输出变量
delta_u = linspace(-1, 1, 5);  % 控制增量

% 设计隶属度函数
e_mf = trimf(e, [-2, -1, 0]); % 误差的隶属度函数
ec_mf = trimf(ec, [-2, -1, 0]); % 误差变化率的隶属度函数
u_mf = trimf(u, [-10, -5, 0]); % 控制量的隶属度函数
delta_u_mf = trapmf(delta_u, [-1, -0.5, 0, 0.5]); % 控制增量的隶属度函数

% 绘制隶属度函数图像
figure(1)
subplot(2, 2, 1)
plot(e, e_mf)
title('误差的隶属度函数')
xlabel('误差')
ylabel('隶属度')

subplot(2, 2, 2)
plot(ec, ec_mf)
title('误差变化率的隶属度函数')
xlabel('误差变化率')
ylabel('隶属度')

subplot(2, 2, 3)
plot(u, u_mf)
title('控制量的隶属度函数')
xlabel('控制量')
ylabel('隶属度')

subplot(2, 2, 4)
plot(delta_u, delta_u_mf)
title('控制增量的隶属度函数')
xlabel('控制增量')
ylabel('隶属度')

% 设定输入和输出的模糊矩阵
% 行数为误差的个数，列数为误差变化率的个数，第三维为控制量的个数
input_mf = zeros(5, 5, 5);
output_mf = zeros(5, 5, 5);

% 构造输入和输出的模糊矩阵
for i = 1:5
    for j = 1:5
        for k = 1:5
            input_mf(i, j, k) = min(e_mf(i), min(ec_mf(j), u_mf(k))); % 输入模糊矩阵
            output_mf(i, j, k) = delta_u_mf(3 + round((k - 3) * (1 + min(e_mf(i), ec_mf(j))))); % 输出模糊矩阵，使用S函数变换
        end
    end
end

% 绘制输入和输出的模糊矩阵
figure(2)
for i = 1:5
    subplot(2, 3, i)
    surf(ec, e, input_mf(:, :, i)')
    title(['控制量为', num2str(u(i))])
    xlabel('误差变化率')
    ylabel('误差')
    zlabel('隶属度')
end

figure(3)
for i = 1:5
    subplot(2, 3, i)
    surf(ec, e, output_mf(:, :, i)')
    title(['控制量为', num2str(u(i))])
    xlabel('误差变化率')
    ylabel('误差')
    zlabel('隶属度')
end

% 设定被控对象
s = tf('s');
P = Wn^2 / (s^2 + 2*Zeta*Wn*s + Wn^2);

% 设定控制器的初始状态
e0 = 0;
ec0 = 0;
u0 = 0;

% 设定仿真时间和步长
t = 0:0.01:10;

% 进行模糊控制的仿真
for i = 1:length(t)
    % 计算误差和误差变化率
    e1 = e0 - P * u0;
    ec1 = ec0 - P * (u0 - u_range(1)) / (u_range(2) - u_range(1));
    
    % 计算输入模糊矩阵的隶属度值
    input_mf_value = zeros(5, 5, 5);
    for j = 1:5
        for k = 1:5
            input_mf_value(:, j, k) = input_mf(:, j, k) * min(e_mf, e1)';
        end
    end
    
    % 计算输出模糊矩阵的隶属度值
    output_mf_value = zeros(5, 5, 5);
    for j = 1:5
        for k = 1:5
            output_mf_value(:, j, k) = output_mf(:, j, k) * input_mf_value(:, j, k);
        end
    end
    
    % 计算控制增量
    delta_u_value = zeros(5, 5, 5);
    for j = 1:5
        for k = 1:5
            delta_u_value(:, j, k) = output_mf_value(:, j, k) * delta_u';
        end
    end
    
    % 解模糊，使用重心法
    delta_u1 = sum(sum(sum(delta_u_value .* delta_u))) / sum(sum(sum(delta_u_value)));
    
    % 计算控制量
    u1 = u0 + delta_u1;
    
    % 更新初始状态
    e0 = e1;
    ec0 = ec1;
    u0 = u1;
    
    % 记录仿真结果
    e(i) = e1;
    ec(i) = ec1;
    u(i) = u1;
end

% 绘制仿真结果
figure(4)
subplot(3, 1, 1)
plot(t, e)
title('误差')
xlabel('时间')
ylabel('误差')

subplot(3, 1, 2)
plot(t, ec)
title('误差变化率')
xlabel('时间')
ylabel('误差变化率')

subplot(3, 1, 3)
plot(t, u)
title('控制量')
xlabel('时间')
ylabel('控制量')

代码中采用了重心法进行模糊控制器的解模糊，通过绘制隶属度函数图像和仿真图象，可以更直观地了解模糊控制器的性能和参数设计的合理性。

设计被控对象为二阶过阻尼传递函数的三输入单输出的模糊控制器的M语言仿真，采用重心法解模糊，编写完整代码

以下是设计被控对象为二阶过阻尼传递函数的三输入单输出的模糊控制器的M语言仿真，并采用重心法解模糊的完整代码：

% 设计被控对象为二阶过阻尼传递函数的三输入单输出的模糊控制器的M语言仿真
% 采用重心法解模糊

clc;
clear;

% 定义模糊控制器的输入和输出变量
x = 0:0.1:10;
y = 0:0.1:10;
z = 0:0.1:10;
u = 0:0.1:10;

% 定义模糊控制器的输入和输出隶属度函数
% 输入变量x的隶属度函数
A1 = gaussmf(x,[1.5 3]);
A2 = gaussmf(x,[1.5 5]);
A3 = gaussmf(x,[1.5 7]);

% 输入变量y的隶属度函数
B1 = gaussmf(y,[1.5 3]);
B2 = gaussmf(y,[1.5 5]);
B3 = gaussmf(y,[1.5 7]);

% 输入变量z的隶属度函数
C1 = gaussmf(z,[1.5 3]);
C2 = gaussmf(z,[1.5 5]);
C3 = gaussmf(z,[1.5 7]);

% 输出变量u的隶属度函数
D1 = gaussmf(u,[1.5 3]);
D2 = gaussmf(u,[1.5 5]);
D3 = gaussmf(u,[1.5 7]);

% 定义规则库
% 规则库的三个输入分别为x、y、z，输出为u
% 规则库中的数字表示对应隶属度函数的下标
rule1 = [1,1,1,1];
rule2 = [1,1,2,2];
rule3 = [1,1,3,3];
rule4 = [1,2,1,1];
rule5 = [1,2,2,2];
rule6 = [1,2,3,3];
rule7 = [1,3,1,1];
rule8 = [1,3,2,2];
rule9 = [1,3,3,3];

rule10 = [2,1,1,1];
rule11 = [2,1,2,2];
rule12 = [2,1,3,3];
rule13 = [2,2,1,2];
rule14 = [2,2,2,2];
rule15 = [2,2,3,3];
rule16 = [2,3,1,2];
rule17 = [2,3,2,3];
rule18 = [2,3,3,3];

rule19 = [3,1,1,2];
rule20 = [3,1,2,2];
rule21 = [3,1,3,3];
rule22 = [3,2,1,2];
rule23 = [3,2,2,3];
rule24 = [3,2,3,3];
rule25 = [3,3,1,3];
rule26 = [3,3,2,3];
rule27 = [3,3,3,3];

% 将规则库保存到矩阵中
rules = [rule1;rule2;rule3;rule4;rule5;rule6;rule7;rule8;rule9;rule10;rule11;rule12;rule13;rule14;rule15;rule16;rule17;rule18;rule19;rule20;rule21;rule22;rule23;rule24;rule25;rule26;rule27];

% 定义被控对象的传递函数
num = [1 0.5];
den = [1 1 0.5];

% 定义控制器的初始值
u0 = 0;

% 定义控制器的增量值
deltau = 0.01;

% 定义控制器的最大输出值和最小输出值
umax = 10;
umin = 0;

% 定义模拟时间和步长
t = 0:0.01:50;

% 定义控制器的输出和误差
uout = zeros(size(t));
e = zeros(size(t));

% 进行模拟
for k = 3:length(t)
    % 获取被控对象的当前误差
    e(k) = 1.5*sin(0.2*t(k)) - uout(k-1);

    % 计算控制器的输入
    input = [A1(round(e(k)/0.1)+1) A2(round(e(k)/0.1)+1) A3(round(e(k)/0.1)+1) ...
             B1(round(e(k-1)/0.1)+1) B2(round(e(k-1)/0.1)+1) B3(round(e(k-1)/0.1)+1) ...
             C1(round(e(k-2)/0.1)+1) C2(round(e(k-2)/0.1)+1) C3(round(e(k-2)/0.1)+1)];
    % 计算控制器的输出
    uout(k) = defuzz(rules,input,'centroid');
    % 限制控制器的输出在最大值和最小值之间
    uout(k) = min(max(uout(k),umin),umax);
end

% 绘制控制器的输入和输出曲线
figure;
plot(t,e,'r',t,uout,'b');
xlabel('Time (s)');
ylabel('System Response');
title('Fuzzy Control of a Second-order System');
legend('Error','Output');
grid on;

其中，`gaussmf` 函数是用于定义隶属度函数的高斯型隶属度函数，`defuzz` 函数是用于解模糊的函数，采用的是重心法解模糊。在模拟过程中，我们首先计算被控对象的当前误差，然后根据误差、误差的历史值和规则库计算控制器的输入，并使用重心法解模糊得到控制器的输出，最后限制控制器的输出在最大值和最小值之间。最终绘制出控制器的输入和输出曲线，以反映系统的控制效果。