模糊控制算法-转载

最新推荐文章于 2024-09-25 22:04:12 发布
最新推荐文章于 2024-09-25 22:04:12 发布
阅读量5.4k 收藏 18
点赞数

之前写过一篇关于使用样本数据获取模糊规则的博文，原文 的地址是：http://blog.csdn.net/shuoyueqishilove/article/details/71908410，大家可以参考，本篇文章适合对模糊控制算法有一定了解的人阅读，给大家提供一种如何用C++实现模糊控制的方法，仅供参考。 
实现模糊控制器需要以下步骤：

确定模糊控制器的输入和输出量
设计模糊控制器的控制规则
确立模糊化和非模糊化的方法
选择模糊控制器的输入变量和输出变量的论域并确定模糊控制器的参数（如量化因子，比例因子等）
编制模糊控制算法的应用程序
合理选择模糊控制算法的采样时间

本模糊控制器采用双输入单输出的形式，输入变量为误差e和误差的变化率de,输出为控制量u；e,de,u的量化论域范围为[-3,-2,-1,0,1,2,3],划分的模糊子集为：[NB,NM,NS,ZO,PS,PM,PB].基本论域的范围选取需要根据实际情况来确定上限值emax,demax,umax. 
量化因子:Ke=3/emax, Kde=3/demax, 
输出缩放因子：Ku=umax/3 
为了减少计算量，e,de,u的隶属度函数都选用三角形隶属度函数。如下图所示： 
 
模糊控制最重要的是要确定模糊控制规则，它可以通过专家经验获得，也可以通过采样数据获得，这里使用的模糊控制规则表如下； 
 
在微处理器中实现模糊控制的一般采用离线查表的方法。首先模糊化输入到控制器中的e和de，计算他们的在每个模糊子集中的隶属度值，然后找出激活的模糊子集，存储起来，最后使用加权平均的方法计算输出值。具体的公式如下： 
 
Zi为u的模糊隶属度函数的尖点所对应的横坐标值。 
下面讲讲怎么用C++实现模糊控制器。 
首先需要建立一个Fuzzy_controller的类：

class Fuzzy_controller
{
public:
    const static int N=7;//定义量化论域模糊子集的个数
private:
    float target;//系统的控制目标
    float actual;//采样获得的实际值
    float e;     //误差
    float e_pre; //上一次的误差
    float de;    //误差的变化率
    float emax;  //误差基本论域上限
    float demax; //误差辩化率基本论域的上限
    float umax;  //输出的上限
    float Ke;    //Ke=n/emax,量化论域为[-3,-2,-1,0,1,2,3]
    float Kde;   //Ke=n/demax,量化论域为[-3,-2,-1,0,1,2,3]
    float Ku;    //Ke=umax/n,量化论域为[-3,-2,-1,0,1,2,3]
    int rule[N][N];//模糊规则表
    string mf_t_e;   //e的隶属度函数类型
    string mf_t_de;  //de的隶属度函数类型
    string mf_t_u;   //u的隶属度函数类型
    float *e_mf_paras; //误差的隶属度函数的参数
    float *de_mf_paras;//误差的偏差隶属度函数的参数
    float *u_mf_paras; //输出的隶属度函数的参数

public:
    Fuzzy_controller(float e_max,float de_max,float u_max);
    ~Fuzzy_controller();
    float trimf(float x,float a,float b,float c);          //三角隶属度函数
    float gaussmf(float x,float ave,float sigma);          //正态隶属度函数
    float trapmf(float x,float a,float b,float c,float d); //梯形隶属度函数
    //设置模糊隶属度函数的参数
    void setMf(const string & mf_type_e,float *e_mf,const string & mf_type_de,float *de_mf,const string & mf_type_u,float *u_mf);
    void setRule(int rulelist[N][N]);                          //设置模糊规则
    float realize(float t,float a);              //实现模糊控制
    void showInfo();                                      //显示该模糊控制器的信息
    void showMf(const string & type,float *mf_paras);      //显示隶属度函数的信息
};
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
然后给出类方法的定义：

Fuzzy_controller::Fuzzy_controller(float e_max,float de_max,float u_max):
target(0),actual(0),emax(e_max),demax(de_max),umax(u_max),e_mf_paras(NULL),de_mf_paras(NULL),u_mf_paras(NULL)
{
   e=target-actual;
   e_pre=0;
   de=e-e_pre;
   Ke=(N/2)/emax;
   Kde=(N/2)/demax;
   Ku=umax/(N/2);
   mf_t_e="trimf";
   mf_t_de="trimf";
   mf_t_u="trimf";
}

Fuzzy_controller::~Fuzzy_controller()
{
  delete [] e_mf_paras;
  delete [] de_mf_paras;
  delete [] u_mf_paras;
}
//三角隶属度函数
float Fuzzy_controller::trimf(float x,float a,float b,float c)
{
   float u;
   if(x>=a&&x<=b)
       u=(x-a)/(b-a);
   else if(x>b&&x<=c)
       u=(c-x)/(c-b);
   else
       u=0.0;
   return u;

}
//正态隶属度函数
float Fuzzy_controller::gaussmf(float x,float ave,float sigma) 
{
    float u;
    if(sigma<0)
    {
       cout<<"In gaussmf, sigma must larger than 0"<<endl;
    }
    u=exp(-pow(((x-ave)/sigma),2));
    return u;
}
//梯形隶属度函数
float Fuzzy_controller::trapmf(float x,float a,float b,float c,float d)
{
    float u;
    if(x>=a&&x<b)
        u=(x-a)/(b-a);
    else if(x>=b&&x<c)
        u=1;
    else if(x>=c&&x<=d)
        u=(d-x)/(d-c);
    else
        u=0;
    return u;
}
//设置模糊规则
void Fuzzy_controller::setRule(int rulelist[N][N])
{
    for(int i=0;i<N;i++)
       for(int j=0;j<N;j++)
         rule[i][j]=rulelist[i][j];
}

//设置模糊隶属度函数的类型和参数
void Fuzzy_controller::setMf(const string & mf_type_e,float *e_mf,const string & mf_type_de,float *de_mf,const string & mf_type_u,float *u_mf)
{
    if(mf_type_e=="trimf"||mf_type_e=="gaussmf"||mf_type_e=="trapmf")
        mf_t_e=mf_type_e;
    else
        cout<<"Type of membership function must be \"trimf\" or \"gaussmf\" or \"trapmf\""<<endl;

    if(mf_type_de=="trimf"||mf_type_de=="gaussmf"||mf_type_de=="trapmf")
        mf_t_de=mf_type_de;
    else
        cout<<"Type of membership function must be \"trimf\" or \"gaussmf\" or \"trapmf\""<<endl;

    if(mf_type_u=="trimf"||mf_type_u=="gaussmf"||mf_type_u=="trapmf")
        mf_t_u=mf_type_u;
    else
        cout<<"Type of membership function must be \"trimf\" or \"gaussmf\" or \"trapmf\""<<endl;
    e_mf_paras=new float [N*3];
    de_mf_paras=new float [N*3];
    u_mf_paras=new float [N*3];
    for(int i=0;i<N*3;i++)
       e_mf_paras[i]=e_mf[i];
    for(int i=0;i<N*3;i++)
       de_mf_paras[i]=de_mf[i];
    for(int i=0;i<N*3;i++)
       u_mf_paras[i]=u_mf[i];
}
//实现模糊控制
float Fuzzy_controller::realize(float t,float a)   
{
    float u_e[N],u_de[N],u_u[N];
    int u_e_index[3],u_de_index[3];//假设一个输入最多激活3个模糊子集
    float u;
    int M;
    target=t;
    actual=a;
    e=target-actual;
    de=e-e_pre;
    e=Ke*e;
    de=Kde*de;
    if(mf_t_e=="trimf")
        M=3;               //三角函数有三个参数
    else if(mf_t_e=="gaussmf")
        M=2;              //正态函数有两个参数
    else if(mf_t_e=="trapmf")
        M=4;              //梯形函数有四个参数
    int j=0;
    for(int i=0;i<N;i++)
    {
        u_e[i]=trimf(e,e_mf_paras[i*M],e_mf_paras[i*M+1],e_mf_paras[i*M+2]);//e模糊化，计算它的隶属度
        if(u_e[i]!=0)
            u_e_index[j++]=i;                                              //存储被激活的模糊子集的下标，可以减小计算量
    }
    for(;j<3;j++)u_e_index[j]=0;

    if(mf_t_e=="trimf")
        M=3;              //三角函数有三个参数
    else if(mf_t_e=="gaussmf")
        M=2;              //正态函数有两个参数
    else if(mf_t_e=="trapmf")
        M=4;               //梯形函数有四个参数
    j=0;
    for(int i=0;i<N;i++)
    {
        u_de[i]=trimf(de,de_mf_paras[i*M],de_mf_paras[i*M+1],de_mf_paras[i*M+2]);//de模糊化，计算它的隶属度
        if(u_de[i]!=0)
            u_de_index[j++]=i;                                                    //存储被激活的模糊子集的下标，可以减小计算量
    }
    for(;j<3;j++)u_de_index[j]=0;

    float den=0,num=0;
    for(int m=0;m<3;m++)
        for(int n=0;n<3;n++)
        {
           num+=u_e[u_e_index[m]]*u_de[u_de_index[n]]*rule[u_e_index[m]][u_de_index[n]];
           den+=u_e[u_e_index[m]]*u_de[u_de_index[n]];
        }
    u=num/den;
    u=Ku*u;
    if(u>=umax)   u=umax;
    else if(u<=-umax)  u=-umax;
    e_pre=e;
    return u;
}
void Fuzzy_controller::showMf(const string & type,float *mf_paras)
{
    int tab;
    if(type=="trimf")
        tab=2;
    else if(type=="gaussmf")
        tab==1;
    else if(type=="trapmf")
        tab=3;
    cout<<"函数类型："<<mf_t_e<<endl;
    cout<<"函数参数列表："<<endl;
    float *p=mf_paras;
    for(int i=0;i<N*(tab+1);i++)
      {
          cout.width(3);
          cout<<p[i]<<"  ";
          if(i%3==tab)
              cout<<endl;
      }
}
void Fuzzy_controller::showInfo()
{
   cout<<"Info of this fuzzy controller is as following:"<<endl;
   cout<<"基本论域e：["<<-emax<<","<<emax<<"]"<<endl;
   cout<<"基本论域de：["<<-demax<<","<<demax<<"]"<<endl;
   cout<<"基本论域u：["<<-umax<<","<<umax<<"]"<<endl;
   cout<<"误差e的模糊隶属度函数参数："<<endl;
   showMf(mf_t_e,e_mf_paras);
   cout<<"误差变化率de的模糊隶属度函数参数："<<endl;
   showMf(mf_t_de,de_mf_paras);
   cout<<"输出u的模糊隶属度函数参数："<<endl;
   showMf(mf_t_u,u_mf_paras);
   cout<<"模糊规则表："<<endl;
   for(int i=0;i<N;i++)
   {
     for(int j=0;j<N;j++)
       {
         cout.width(3);
         cout<<rule[i][j]<<"  ";
        }
       cout<<endl;
   }
   cout<<endl;
   cout<<"误差的量化比例因子Ke="<<Ke<<endl;
   cout<<"误差变化率的量化比例因子Kde="<<Kde<<endl;
   cout<<"输出的量化比例因子Ku="<<Ku<<endl;
   cout<<"设定目标target="<<target<<endl;
   cout<<"误差e="<<e<<endl;
   cout<<endl;
}
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
此模糊控制的类，允许用户使用不同的模糊隶属度函数，如三角型，正态分布型和梯形。但是需要相应的给出适当的函数参数。用户可以修改模糊控制规则表，以提高模糊控制器的性能。但是用户需要首先明确误差e，误差变化率de和输出u的最大范围，因为这里需要依据他们来确定量化因子和缩放因子，如果给出的范围不合适，则很难达到理想的控制效果。 
下面是一个测试的例子，仅供参考：

#include<iostream>
#include"fuzzy_controller.h"
#define NB -3
#define NM -2
#define NS -1
#define ZO 0
#define PS 1
#define PM 2
#define PB 3


int main()
{
    float target=600;
    float actual=0;
    float u=0;
    int ruleMatrix[7][7]={{NB,NB,NM,NM,NS,ZO,ZO},
                          {NB,NB,NM,NS,NS,ZO,PS},
                          {NM,NM,NM,NS,ZO,PS,PS},
                          {NM,NM,NS,ZO,PS,PM,PM},
                          {NS,NS,ZO,PS,PS,PM,PM},
                          {NS,ZO,PS,PM,PM,PM,PB},
                          {ZO,ZO,PM,PM,PM,PB,PB}};//模糊规则表
    float e_mf_paras[21]={-3,-3,-2,-3,-2,-1,-2,-1,0,-1,0,1,0,1,2,1,2,3,2,3,3};//误差e的隶属度函数参数，这里隶属度函数为三角型，所以3个数据为一组
    float de_mf_paras[21]={-3,-3,-2,-3,-2,-1,-2,-1,0,-1,0,1,0,1,2,1,2,3,2,3,3};//误差变化率de的模糊隶属度函数参数
    float u_mf_paras[21]={-3,-3,-2,-3,-2,-1,-2,-1,0,-1,0,1,0,1,2,1,2,3,2,3,3};//输出量u的隶属度函数参数
    Fuzzy_controller fuzzy(1000,650,500);//控制器初始化，设定误差，误差变化率，输出的最大值
    fuzzy.setMf("trimf",e_mf_paras,"trimf",de_mf_paras,"trimf",u_mf_paras);//设定模糊隶属度函数
    fuzzy.setRule(ruleMatrix);//设定模糊规则
    cout<<"num   target    actual"<<endl;
    for(int i=0;i<100;i++)
    {
        u=fuzzy.realize(target,actual);
        actual+=u;
        cout<<i<<"      "<<target<<"      "<<actual<<endl;
    }
    fuzzy.showInfo();
    system("pause");
    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
35
36
37
38
39
40
运行结果： 
 
这里设定的目标值为600,可见，控制器在运行到9次时就稳定在了600,控制效果比较好。 
代码已上传至我的CSDN，有兴趣的可以下载看看： 
https://download.csdn.net/download/shuoyueqishilove/10433961
--------------------- 
作者：shuoyueqishilove 
来源：CSDN 
原文：https://blog.csdn.net/shuoyueqishilove/article/details/74029745 
版权声明：本文为博主原创文章，转载请附上博文链接！

dzh28465
关注
模糊控制（FL）算法
James_bobo的博客
10-21 3万+
模糊控制算法(理论知识) 模糊（Fuzzy）控制是用语言归纳操作人员的控制策略，运用语言变量和模糊集合理论形成控制算法的一种控制。模糊控制的最重要特征是不需要建立被控对象精确的数学模型，只要求把现场操作人员的经验和数据总结成较完善的语言控制规则，从而能够对具有不确定性、不精确性、噪声以及非线性、时变性、时滞等特征的控制对象进行控制。模糊控制系统的鲁棒性强，尤其适用于非线性、时变、滞后系统的控制。模糊控制的基本结构如图所示。 1．模糊控制器的输入变量与输出变量 （1）模糊控制器的输入、输出变量 模糊控制器是
模糊控制算法
qq_43772564的博客
10-22 1439
模糊集合 人们的思维中的很多概念没有明确的外延，如“大”、“中”、“小”等，这些模糊概念不能用经典集合加以描述。1965 年 Zadeh 教授提出用模糊集合来描述这些模糊概念，其定义如下： 给定论域 U，U 到[0，1]闭区间的任一映射 ， ：U→[0,1]，u→ 。 称为确定了 U 的一个模糊子集 A， 称为模糊子集的隶属函数， 称为u 对于 A的隶属度，反映了 u 对模糊子集 A的从...
基于MATLAB_SIMULINK的自调整因子模糊控制器的设计与仿真.pdf
07-03
基于MATLAB_SIMULINK的自调整因子模糊控制器的设计与仿真.pdf
[智能控制】【第2 章 模糊控制的理论基础】
最新发布
persona5joker的博客
09-25 1479
模糊控制理论的提出，模糊集合，运算，模糊算子，隶属函数，矩阵合成
控制算法（二）—— 模糊控制算法
bigmarshal的博客
03-19 2万+
模糊控制是以模糊集理论、模糊语言变量和模糊逻辑推理为基础的一种智能控制方法，它是从行为上模仿人的模糊推理和决策过程的一种智能控制算法。模糊控制首先将操作人员或专家经验编成模糊规则，然后将来自传感器的实时信号模糊化，将模糊化后的信号作为模糊规则的输入，完成模糊推理，将推理后得到的输出量加到执行器上。 模糊控制的过程如下图所示。 上图中，包括了模糊...
模糊控制详解
热门推荐
kidney_ye的博客
11-19 5万+
描述输入和输出变量的词集 在模糊控制中，输入输出变量大小是以语言形式描述的，一般都选用大中小三个词汇来描述模糊控制器的输入，输出变量的状态，再加上正负两个方向和零状态，共有7个词汇： {负大，负中，负小，零，正小，正中，正大} 一般用这些词的英文字头缩写为： {NB,NM,NS,O,PS,PM,PB} 为了提高系统稳态精度，通常在误差接近于零时增加分辨率，将零又分为整零和负零，因此，描述误差变量的刺集一般取为： {负大，负中，负小，负零，正零，正小，正中，正大} 用英文字头简记为： {NB,NM,NS,NO
通俗的模糊控制算法讲解
04-24
用比较通俗的语言讲解模糊控制算法，适合有一定基础的人
非常好用的模糊pid温度控制算法_PID参数调试“口诀”，总结的真好！
weixin_39632379的博客
11-22 7038
猜你喜欢01.电力基础知识大普及，工程师们都收藏了！！02.电力系统分析全套课程03.【干货】超全的电厂常用计算Excel表格合集04.电机知识，这里有一份沉甸甸的硬货！05.高低压配电系统基础知识(值得收藏)附PPT06.什么是功率因数？一文讲透07.工作票和操作票培训PPT，这篇文章讲明白了！08.电能表的接线方式详解，值得收藏！09.电气二次控制回路和多种元器件基础讲解，猛料！10...
计算智能学习3_模糊算法/模糊聚类理解_K-means实际应用_FCM算法实现_matlab实现
zxm_的博客
02-26 8696
模糊算法 实 验 报 告 实验名称：模糊算法 一、需求分析 本实验为了解和测试模糊算法并在实际背景下进行应用。 1、 寻找合适的具有实际意义的数据集。 2、 根据数据集进行matlab自带的kmeans函数和fcm函数进行分类与分析。 3、 自己设计算法myKmeans函数对数据集进行分类。 数据集1：威斯康星州乳腺癌数据集 原因：目前癌症的初步检测还是主要依靠医生的经验判断，为了提高医生...
连续论域模糊控制，博途1200程序代码
351150613的博客
09-12 5358
二输入单输出模糊控制 编写时间：2015.8.27 作者：QQ351150613 转载请注明作者 一、说明         本想在互联网上找到类似程序修改使用的，结果找遍整个互联网，没有找到可用的模糊控制C语音代码，自己研究模糊控制连续算法，终于小有所成，公布代码，不想那天我挂了，这个算法再没人知道。         我先用KEIL4的80c51测试完成，转到西门子博途中。    
模糊控制算法详细讲解
weixin_33758863的博客
01-10 3960
双输入单输出模糊控制器详细设计流程 一、模糊语言确定及等级划分 　　如表1是模糊语言的确定，认为确定 　　 表1 模糊语言表 人类模糊语言 负大 负中 负小 负零 正零 正小 正中 正大 符号 NL　 NM NS N0 P0 PS PM PL 　　对于人类模糊语言，每一个语言（例如：负大）分成 -6 -5 -4 -3 ...
matlab模糊控制图怎么导出_matlab模糊控制工具箱的使用
weixin_42301889的博客
02-07 4811
本学期选修了周川老师的智能控制及应用这门课程，大三时候曾上过周老师的英文版的控制工程基础这门课程，比较喜欢周老师上课的风格，智能控制这门课也收获不小，模糊控制是课程中讲到的第一个智能控制算法。模糊不是真的模糊，模糊是为了精确。模糊控制中涉及到一个隶属度的概念，通常我们认为一个事物属于一个概念与否是确定的，比如数字电路的0与1，但是实际情况或者人们的思维习惯却不是这样的。比如规定18到30岁为青年，...
模糊控制
jpmf007的专栏
01-29 4027
1965年美国控制理论专家扎德教授首先提出了模糊集合的概念，1973年，扎德继续丰富和发展模糊集合论，提出了一种把逻辑规则语言转化成相关控制量的思想，为模糊控制的形成奠定了理论基础。1974年英国科学家曼丹尼首次将模糊集理论应用于蒸汽机的控制系统中。 1979年开始，我国也开展了模糊控制理论及其应用方面的研究工作。 模糊控制用语言变量代替数学变量或两者结合，以模糊条件语句来刻画变量间的函数关系
Matlab中量化因子和比例因子,模糊控制器设计中量化因子_比例因子的选择
weixin_32244597的博客
03-24 6784
Ξ　收稿日期:2008-11-15作者简介:王川川(1985—),男,河南濮阳人,硕士研究生,主要从事军用电力系统测试技术的研究.模糊控制器设计中量化因子、比例因子的选择Ξ王川川a ,赵锦成a ,齐晓慧b(军械工程学院a.电气工程系;b.光学与电子工程系,石家庄　050003)摘要:以一个具体的电机系统为控制对象,通过Matlab 编程,设计了模糊控制系统的仿真模型通过修改量化因子和比例因子,得到...
模糊控制理论总结
doudou2weiwei的博客
09-11 3001
本文主要介绍了模糊理论基础与模糊控制系统及其设计方法
模糊控制(一）
shuijinghua的博客
10-08 4万+
不足 1）精度不够高 2）自适应能力有限 3）会产生振荡 4）控制规则的结构和覆盖面不恰当 5）比例因子和量化银子选择不当 6）对中心的语言变量值选择不当 7）控制规则优化尚有困难 模糊语言 定义：一个四元组FL=(U,T,E,N) 其中，U为论域，T模糊集合，E，N模糊关系 例如：U为年龄0~·00的集合，即U=[0,100] E为汉语中描述年龄的集合 T为E的子集 ...
模糊控制器基础知识的学习(7.5第一遍，7.6第二遍)
weixin_44287946的博客
07-05 1万+
模糊控制器设计 模糊化接口 ①在模糊化系统中，通常取系统的误差值e和误差变化率ec为模糊控制器的两个输入，则e上定义语言变量“误差E",在ec上定义语言变量”误差变化ec"; 误差和误差变化之间存在和关系，即需要考虑两者对系统的影响。 ②定义各语言的论域。通常都设置为X=Y={-6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6}; ③设置各语言的语言值。通常设为{正大 正中 正小 零 负小 负中 负大}={PB PM PositiveSmall ZO NS NM NB} ④各语言变量上
模糊控制笔记（三）模糊控制系统与模糊PID
高能阿博特的博客
08-24 6425
模糊控制笔记（三）模糊控制系统与模糊PID1. 模糊控制系统1) 量化2) 模糊控制系统组成3) 模糊规则2. 模糊PID 本文章所有知识点均为作者本人学习刘杰、李允公等老师的教材《智能控制与MATLAB实用技术》时所作笔记，在此发自肺腑地表达对老师们辛勤劳动的感谢和尊敬，也安利一下这本书，对入门智能控制的同学们来说是一本极其优秀的教材！ 1. 模糊控制系统 1) 量化 一般地，根据输入信号的取值，将其分为几个等级，即进行量化的操作。如，设输入信号x∈[1,10]x \in [1,10]x∈[1,10]，我
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值